hellomalif.pb.h

Go to the documentation of this file.

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: hellomalif.proto
 
#ifndef PROTOBUF_INCLUDED_hellomalif_2eproto
#define PROTOBUF_INCLUDED_hellomalif_2eproto
 
#include <string>
 
#include <google/protobuf/stubs/common.h>
 
#if GOOGLE_PROTOBUF_VERSION < 3006000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please update
#error your headers.
#endif
#if 3006000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please
#error regenerate this file with a newer version of protoc.
#endif
 
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/inlined_string_field.h>
#include <google/protobuf/metadata.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/unknown_field_set.h>
#include "zpb.pb.h"
#include "malTypes.pb.h"
// @@protoc_insertion_point(includes)
#define PROTOBUF_INTERNAL_EXPORT_protobuf_hellomalif_2eproto 
 
namespace protobuf_hellomalif_2eproto {
// Internal implementation detail -- do not use these members.
struct TableStruct {
  static const ::google::protobuf::internal::ParseTableField entries[];
  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
  static const ::google::protobuf::internal::ParseTable schema[26];
  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
  static const ::google::protobuf::internal::SerializationTable serialization_table[];
  static const ::google::protobuf::uint32 offsets[];
};
void AddDescriptors();
}  // namespace protobuf_hellomalif_2eproto
namespace generated {
namespace zpb {
namespace hellomalif {
class ExceptionErr;
class ExceptionErrDefaultTypeInternal;
extern ExceptionErrDefaultTypeInternal _ExceptionErr_default_instance_;
class LogInfo;
class LogInfoDefaultTypeInternal;
extern LogInfoDefaultTypeInternal _LogInfo_default_instance_;
class StdCmds_Call;
class StdCmds_CallDefaultTypeInternal;
extern StdCmds_CallDefaultTypeInternal _StdCmds_Call_default_instance_;
class StdCmds_Disable_In;
class StdCmds_Disable_InDefaultTypeInternal;
extern StdCmds_Disable_InDefaultTypeInternal _StdCmds_Disable_In_default_instance_;
class StdCmds_Disable_Out;
class StdCmds_Disable_OutDefaultTypeInternal;
extern StdCmds_Disable_OutDefaultTypeInternal _StdCmds_Disable_Out_default_instance_;
class StdCmds_Enable_In;
class StdCmds_Enable_InDefaultTypeInternal;
extern StdCmds_Enable_InDefaultTypeInternal _StdCmds_Enable_In_default_instance_;
class StdCmds_Enable_Out;
class StdCmds_Enable_OutDefaultTypeInternal;
extern StdCmds_Enable_OutDefaultTypeInternal _StdCmds_Enable_Out_default_instance_;
class StdCmds_Exit_In;
class StdCmds_Exit_InDefaultTypeInternal;
extern StdCmds_Exit_InDefaultTypeInternal _StdCmds_Exit_In_default_instance_;
class StdCmds_Exit_Out;
class StdCmds_Exit_OutDefaultTypeInternal;
extern StdCmds_Exit_OutDefaultTypeInternal _StdCmds_Exit_Out_default_instance_;
class StdCmds_GetState_In;
class StdCmds_GetState_InDefaultTypeInternal;
extern StdCmds_GetState_InDefaultTypeInternal _StdCmds_GetState_In_default_instance_;
class StdCmds_GetState_Out;
class StdCmds_GetState_OutDefaultTypeInternal;
extern StdCmds_GetState_OutDefaultTypeInternal _StdCmds_GetState_Out_default_instance_;
class StdCmds_GetStatus_In;
class StdCmds_GetStatus_InDefaultTypeInternal;
extern StdCmds_GetStatus_InDefaultTypeInternal _StdCmds_GetStatus_In_default_instance_;
class StdCmds_GetStatus_Out;
class StdCmds_GetStatus_OutDefaultTypeInternal;
extern StdCmds_GetStatus_OutDefaultTypeInternal _StdCmds_GetStatus_Out_default_instance_;
class StdCmds_GetVersion_In;
class StdCmds_GetVersion_InDefaultTypeInternal;
extern StdCmds_GetVersion_InDefaultTypeInternal _StdCmds_GetVersion_In_default_instance_;
class StdCmds_GetVersion_Out;
class StdCmds_GetVersion_OutDefaultTypeInternal;
extern StdCmds_GetVersion_OutDefaultTypeInternal _StdCmds_GetVersion_Out_default_instance_;
class StdCmds_Init_In;
class StdCmds_Init_InDefaultTypeInternal;
extern StdCmds_Init_InDefaultTypeInternal _StdCmds_Init_In_default_instance_;
class StdCmds_Init_Out;
class StdCmds_Init_OutDefaultTypeInternal;
extern StdCmds_Init_OutDefaultTypeInternal _StdCmds_Init_Out_default_instance_;
class StdCmds_Reply;
class StdCmds_ReplyDefaultTypeInternal;
extern StdCmds_ReplyDefaultTypeInternal _StdCmds_Reply_default_instance_;
class StdCmds_Request;
class StdCmds_RequestDefaultTypeInternal;
extern StdCmds_RequestDefaultTypeInternal _StdCmds_Request_default_instance_;
class StdCmds_Reset_In;
class StdCmds_Reset_InDefaultTypeInternal;
extern StdCmds_Reset_InDefaultTypeInternal _StdCmds_Reset_In_default_instance_;
class StdCmds_Reset_Out;
class StdCmds_Reset_OutDefaultTypeInternal;
extern StdCmds_Reset_OutDefaultTypeInternal _StdCmds_Reset_Out_default_instance_;
class StdCmds_Return;
class StdCmds_ReturnDefaultTypeInternal;
extern StdCmds_ReturnDefaultTypeInternal _StdCmds_Return_default_instance_;
class StdCmds_SetLogLevel_In;
class StdCmds_SetLogLevel_InDefaultTypeInternal;
extern StdCmds_SetLogLevel_InDefaultTypeInternal _StdCmds_SetLogLevel_In_default_instance_;
class StdCmds_SetLogLevel_Out;
class StdCmds_SetLogLevel_OutDefaultTypeInternal;
extern StdCmds_SetLogLevel_OutDefaultTypeInternal _StdCmds_SetLogLevel_Out_default_instance_;
class StdCmds_Stop_In;
class StdCmds_Stop_InDefaultTypeInternal;
extern StdCmds_Stop_InDefaultTypeInternal _StdCmds_Stop_In_default_instance_;
class StdCmds_Stop_Out;
class StdCmds_Stop_OutDefaultTypeInternal;
extern StdCmds_Stop_OutDefaultTypeInternal _StdCmds_Stop_Out_default_instance_;
}  // namespace hellomalif
}  // namespace zpb
}  // namespace generated
namespace google {
namespace protobuf {
template<> ::generated::zpb::hellomalif::ExceptionErr* Arena::CreateMaybeMessage<::generated::zpb::hellomalif::ExceptionErr>(Arena*);
template<> ::generated::zpb::hellomalif::LogInfo* Arena::CreateMaybeMessage<::generated::zpb::hellomalif::LogInfo>(Arena*);
template<> ::generated::zpb::hellomalif::StdCmds_Call* Arena::CreateMaybeMessage<::generated::zpb::hellomalif::StdCmds_Call>(Arena*);
template<> ::generated::zpb::hellomalif::StdCmds_Disable_In* Arena::CreateMaybeMessage<::generated::zpb::hellomalif::StdCmds_Disable_In>(Arena*);
template<> ::generated::zpb::hellomalif::StdCmds_Disable_Out* Arena::CreateMaybeMessage<::generated::zpb::hellomalif::StdCmds_Disable_Out>(Arena*);
template<> ::generated::zpb::hellomalif::StdCmds_Enable_In* Arena::CreateMaybeMessage<::generated::zpb::hellomalif::StdCmds_Enable_In>(Arena*);
template<> ::generated::zpb::hellomalif::StdCmds_Enable_Out* Arena::CreateMaybeMessage<::generated::zpb::hellomalif::StdCmds_Enable_Out>(Arena*);
template<> ::generated::zpb::hellomalif::StdCmds_Exit_In* Arena::CreateMaybeMessage<::generated::zpb::hellomalif::StdCmds_Exit_In>(Arena*);
template<> ::generated::zpb::hellomalif::StdCmds_Exit_Out* Arena::CreateMaybeMessage<::generated::zpb::hellomalif::StdCmds_Exit_Out>(Arena*);
template<> ::generated::zpb::hellomalif::StdCmds_GetState_In* Arena::CreateMaybeMessage<::generated::zpb::hellomalif::StdCmds_GetState_In>(Arena*);
template<> ::generated::zpb::hellomalif::StdCmds_GetState_Out* Arena::CreateMaybeMessage<::generated::zpb::hellomalif::StdCmds_GetState_Out>(Arena*);
template<> ::generated::zpb::hellomalif::StdCmds_GetStatus_In* Arena::CreateMaybeMessage<::generated::zpb::hellomalif::StdCmds_GetStatus_In>(Arena*);
template<> ::generated::zpb::hellomalif::StdCmds_GetStatus_Out* Arena::CreateMaybeMessage<::generated::zpb::hellomalif::StdCmds_GetStatus_Out>(Arena*);
template<> ::generated::zpb::hellomalif::StdCmds_GetVersion_In* Arena::CreateMaybeMessage<::generated::zpb::hellomalif::StdCmds_GetVersion_In>(Arena*);
template<> ::generated::zpb::hellomalif::StdCmds_GetVersion_Out* Arena::CreateMaybeMessage<::generated::zpb::hellomalif::StdCmds_GetVersion_Out>(Arena*);
template<> ::generated::zpb::hellomalif::StdCmds_Init_In* Arena::CreateMaybeMessage<::generated::zpb::hellomalif::StdCmds_Init_In>(Arena*);
template<> ::generated::zpb::hellomalif::StdCmds_Init_Out* Arena::CreateMaybeMessage<::generated::zpb::hellomalif::StdCmds_Init_Out>(Arena*);
template<> ::generated::zpb::hellomalif::StdCmds_Reply* Arena::CreateMaybeMessage<::generated::zpb::hellomalif::StdCmds_Reply>(Arena*);
template<> ::generated::zpb::hellomalif::StdCmds_Request* Arena::CreateMaybeMessage<::generated::zpb::hellomalif::StdCmds_Request>(Arena*);
template<> ::generated::zpb::hellomalif::StdCmds_Reset_In* Arena::CreateMaybeMessage<::generated::zpb::hellomalif::StdCmds_Reset_In>(Arena*);
template<> ::generated::zpb::hellomalif::StdCmds_Reset_Out* Arena::CreateMaybeMessage<::generated::zpb::hellomalif::StdCmds_Reset_Out>(Arena*);
template<> ::generated::zpb::hellomalif::StdCmds_Return* Arena::CreateMaybeMessage<::generated::zpb::hellomalif::StdCmds_Return>(Arena*);
template<> ::generated::zpb::hellomalif::StdCmds_SetLogLevel_In* Arena::CreateMaybeMessage<::generated::zpb::hellomalif::StdCmds_SetLogLevel_In>(Arena*);
template<> ::generated::zpb::hellomalif::StdCmds_SetLogLevel_Out* Arena::CreateMaybeMessage<::generated::zpb::hellomalif::StdCmds_SetLogLevel_Out>(Arena*);
template<> ::generated::zpb::hellomalif::StdCmds_Stop_In* Arena::CreateMaybeMessage<::generated::zpb::hellomalif::StdCmds_Stop_In>(Arena*);
template<> ::generated::zpb::hellomalif::StdCmds_Stop_Out* Arena::CreateMaybeMessage<::generated::zpb::hellomalif::StdCmds_Stop_Out>(Arena*);
}  // namespace protobuf
}  // namespace google
namespace generated {
namespace zpb {
namespace hellomalif {
 
// ===================================================================
 
class ExceptionErr : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:generated.zpb.hellomalif.ExceptionErr) */ {
 public:
  ExceptionErr();
  virtual ~ExceptionErr();
 
  ExceptionErr(const ExceptionErr& from);
 
  inline ExceptionErr& operator=(const ExceptionErr& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  ExceptionErr(ExceptionErr&& from) noexcept
    : ExceptionErr() {
    *this = ::std::move(from);
  }
 
  inline ExceptionErr& operator=(ExceptionErr&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const ExceptionErr& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const ExceptionErr* internal_default_instance() {
    return reinterpret_cast<const ExceptionErr*>(
               &_ExceptionErr_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;
 
  void Swap(ExceptionErr* other);
  friend void swap(ExceptionErr& a, ExceptionErr& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline ExceptionErr* New() const final {
    return CreateMaybeMessage<ExceptionErr>(NULL);
  }
 
  ExceptionErr* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<ExceptionErr>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const ExceptionErr& from);
  void MergeFrom(const ExceptionErr& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ExceptionErr* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // required string desc = 1;
  bool has_desc() const;
  void clear_desc();
  static const int kDescFieldNumber = 1;
  const ::std::string& desc() const;
  void set_desc(const ::std::string& value);
  #if LANG_CXX11
  void set_desc(::std::string&& value);
  #endif
  void set_desc(const char* value);
  void set_desc(const char* value, size_t size);
  ::std::string* mutable_desc();
  ::std::string* release_desc();
  void set_allocated_desc(::std::string* desc);
 
  // @@protoc_insertion_point(class_scope:generated.zpb.hellomalif.ExceptionErr)
 private:
  void set_has_desc();
  void clear_has_desc();
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr desc_;
  friend struct ::protobuf_hellomalif_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class LogInfo : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:generated.zpb.hellomalif.LogInfo) */ {
 public:
  LogInfo();
  virtual ~LogInfo();
 
  LogInfo(const LogInfo& from);
 
  inline LogInfo& operator=(const LogInfo& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  LogInfo(LogInfo&& from) noexcept
    : LogInfo() {
    *this = ::std::move(from);
  }
 
  inline LogInfo& operator=(LogInfo&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const LogInfo& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const LogInfo* internal_default_instance() {
    return reinterpret_cast<const LogInfo*>(
               &_LogInfo_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;
 
  void Swap(LogInfo* other);
  friend void swap(LogInfo& a, LogInfo& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline LogInfo* New() const final {
    return CreateMaybeMessage<LogInfo>(NULL);
  }
 
  LogInfo* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<LogInfo>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const LogInfo& from);
  void MergeFrom(const LogInfo& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LogInfo* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // required string level = 1;
  bool has_level() const;
  void clear_level();
  static const int kLevelFieldNumber = 1;
  const ::std::string& level() const;
  void set_level(const ::std::string& value);
  #if LANG_CXX11
  void set_level(::std::string&& value);
  #endif
  void set_level(const char* value);
  void set_level(const char* value, size_t size);
  ::std::string* mutable_level();
  ::std::string* release_level();
  void set_allocated_level(::std::string* level);
 
  // required string logger = 2;
  bool has_logger() const;
  void clear_logger();
  static const int kLoggerFieldNumber = 2;
  const ::std::string& logger() const;
  void set_logger(const ::std::string& value);
  #if LANG_CXX11
  void set_logger(::std::string&& value);
  #endif
  void set_logger(const char* value);
  void set_logger(const char* value, size_t size);
  ::std::string* mutable_logger();
  ::std::string* release_logger();
  void set_allocated_logger(::std::string* logger);
 
  // @@protoc_insertion_point(class_scope:generated.zpb.hellomalif.LogInfo)
 private:
  void set_has_level();
  void clear_has_level();
  void set_has_logger();
  void clear_has_logger();
 
  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr level_;
  ::google::protobuf::internal::ArenaStringPtr logger_;
  friend struct ::protobuf_hellomalif_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class StdCmds_Init_In : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:generated.zpb.hellomalif.StdCmds_Init_In) */ {
 public:
  StdCmds_Init_In();
  virtual ~StdCmds_Init_In();
 
  StdCmds_Init_In(const StdCmds_Init_In& from);
 
  inline StdCmds_Init_In& operator=(const StdCmds_Init_In& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  StdCmds_Init_In(StdCmds_Init_In&& from) noexcept
    : StdCmds_Init_In() {
    *this = ::std::move(from);
  }
 
  inline StdCmds_Init_In& operator=(StdCmds_Init_In&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const StdCmds_Init_In& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const StdCmds_Init_In* internal_default_instance() {
    return reinterpret_cast<const StdCmds_Init_In*>(
               &_StdCmds_Init_In_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;
 
  void Swap(StdCmds_Init_In* other);
  friend void swap(StdCmds_Init_In& a, StdCmds_Init_In& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline StdCmds_Init_In* New() const final {
    return CreateMaybeMessage<StdCmds_Init_In>(NULL);
  }
 
  StdCmds_Init_In* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<StdCmds_Init_In>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const StdCmds_Init_In& from);
  void MergeFrom(const StdCmds_Init_In& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(StdCmds_Init_In* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // @@protoc_insertion_point(class_scope:generated.zpb.hellomalif.StdCmds_Init_In)
 private:
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_hellomalif_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class StdCmds_Reset_In : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:generated.zpb.hellomalif.StdCmds_Reset_In) */ {
 public:
  StdCmds_Reset_In();
  virtual ~StdCmds_Reset_In();
 
  StdCmds_Reset_In(const StdCmds_Reset_In& from);
 
  inline StdCmds_Reset_In& operator=(const StdCmds_Reset_In& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  StdCmds_Reset_In(StdCmds_Reset_In&& from) noexcept
    : StdCmds_Reset_In() {
    *this = ::std::move(from);
  }
 
  inline StdCmds_Reset_In& operator=(StdCmds_Reset_In&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const StdCmds_Reset_In& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const StdCmds_Reset_In* internal_default_instance() {
    return reinterpret_cast<const StdCmds_Reset_In*>(
               &_StdCmds_Reset_In_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;
 
  void Swap(StdCmds_Reset_In* other);
  friend void swap(StdCmds_Reset_In& a, StdCmds_Reset_In& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline StdCmds_Reset_In* New() const final {
    return CreateMaybeMessage<StdCmds_Reset_In>(NULL);
  }
 
  StdCmds_Reset_In* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<StdCmds_Reset_In>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const StdCmds_Reset_In& from);
  void MergeFrom(const StdCmds_Reset_In& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(StdCmds_Reset_In* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // @@protoc_insertion_point(class_scope:generated.zpb.hellomalif.StdCmds_Reset_In)
 private:
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_hellomalif_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class StdCmds_Enable_In : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:generated.zpb.hellomalif.StdCmds_Enable_In) */ {
 public:
  StdCmds_Enable_In();
  virtual ~StdCmds_Enable_In();
 
  StdCmds_Enable_In(const StdCmds_Enable_In& from);
 
  inline StdCmds_Enable_In& operator=(const StdCmds_Enable_In& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  StdCmds_Enable_In(StdCmds_Enable_In&& from) noexcept
    : StdCmds_Enable_In() {
    *this = ::std::move(from);
  }
 
  inline StdCmds_Enable_In& operator=(StdCmds_Enable_In&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const StdCmds_Enable_In& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const StdCmds_Enable_In* internal_default_instance() {
    return reinterpret_cast<const StdCmds_Enable_In*>(
               &_StdCmds_Enable_In_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;
 
  void Swap(StdCmds_Enable_In* other);
  friend void swap(StdCmds_Enable_In& a, StdCmds_Enable_In& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline StdCmds_Enable_In* New() const final {
    return CreateMaybeMessage<StdCmds_Enable_In>(NULL);
  }
 
  StdCmds_Enable_In* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<StdCmds_Enable_In>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const StdCmds_Enable_In& from);
  void MergeFrom(const StdCmds_Enable_In& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(StdCmds_Enable_In* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // @@protoc_insertion_point(class_scope:generated.zpb.hellomalif.StdCmds_Enable_In)
 private:
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_hellomalif_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class StdCmds_Disable_In : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:generated.zpb.hellomalif.StdCmds_Disable_In) */ {
 public:
  StdCmds_Disable_In();
  virtual ~StdCmds_Disable_In();
 
  StdCmds_Disable_In(const StdCmds_Disable_In& from);
 
  inline StdCmds_Disable_In& operator=(const StdCmds_Disable_In& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  StdCmds_Disable_In(StdCmds_Disable_In&& from) noexcept
    : StdCmds_Disable_In() {
    *this = ::std::move(from);
  }
 
  inline StdCmds_Disable_In& operator=(StdCmds_Disable_In&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const StdCmds_Disable_In& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const StdCmds_Disable_In* internal_default_instance() {
    return reinterpret_cast<const StdCmds_Disable_In*>(
               &_StdCmds_Disable_In_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;
 
  void Swap(StdCmds_Disable_In* other);
  friend void swap(StdCmds_Disable_In& a, StdCmds_Disable_In& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline StdCmds_Disable_In* New() const final {
    return CreateMaybeMessage<StdCmds_Disable_In>(NULL);
  }
 
  StdCmds_Disable_In* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<StdCmds_Disable_In>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const StdCmds_Disable_In& from);
  void MergeFrom(const StdCmds_Disable_In& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(StdCmds_Disable_In* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // @@protoc_insertion_point(class_scope:generated.zpb.hellomalif.StdCmds_Disable_In)
 private:
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_hellomalif_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class StdCmds_GetState_In : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:generated.zpb.hellomalif.StdCmds_GetState_In) */ {
 public:
  StdCmds_GetState_In();
  virtual ~StdCmds_GetState_In();
 
  StdCmds_GetState_In(const StdCmds_GetState_In& from);
 
  inline StdCmds_GetState_In& operator=(const StdCmds_GetState_In& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  StdCmds_GetState_In(StdCmds_GetState_In&& from) noexcept
    : StdCmds_GetState_In() {
    *this = ::std::move(from);
  }
 
  inline StdCmds_GetState_In& operator=(StdCmds_GetState_In&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const StdCmds_GetState_In& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const StdCmds_GetState_In* internal_default_instance() {
    return reinterpret_cast<const StdCmds_GetState_In*>(
               &_StdCmds_GetState_In_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;
 
  void Swap(StdCmds_GetState_In* other);
  friend void swap(StdCmds_GetState_In& a, StdCmds_GetState_In& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline StdCmds_GetState_In* New() const final {
    return CreateMaybeMessage<StdCmds_GetState_In>(NULL);
  }
 
  StdCmds_GetState_In* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<StdCmds_GetState_In>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const StdCmds_GetState_In& from);
  void MergeFrom(const StdCmds_GetState_In& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(StdCmds_GetState_In* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // @@protoc_insertion_point(class_scope:generated.zpb.hellomalif.StdCmds_GetState_In)
 private:
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_hellomalif_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class StdCmds_GetStatus_In : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:generated.zpb.hellomalif.StdCmds_GetStatus_In) */ {
 public:
  StdCmds_GetStatus_In();
  virtual ~StdCmds_GetStatus_In();
 
  StdCmds_GetStatus_In(const StdCmds_GetStatus_In& from);
 
  inline StdCmds_GetStatus_In& operator=(const StdCmds_GetStatus_In& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  StdCmds_GetStatus_In(StdCmds_GetStatus_In&& from) noexcept
    : StdCmds_GetStatus_In() {
    *this = ::std::move(from);
  }
 
  inline StdCmds_GetStatus_In& operator=(StdCmds_GetStatus_In&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const StdCmds_GetStatus_In& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const StdCmds_GetStatus_In* internal_default_instance() {
    return reinterpret_cast<const StdCmds_GetStatus_In*>(
               &_StdCmds_GetStatus_In_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;
 
  void Swap(StdCmds_GetStatus_In* other);
  friend void swap(StdCmds_GetStatus_In& a, StdCmds_GetStatus_In& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline StdCmds_GetStatus_In* New() const final {
    return CreateMaybeMessage<StdCmds_GetStatus_In>(NULL);
  }
 
  StdCmds_GetStatus_In* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<StdCmds_GetStatus_In>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const StdCmds_GetStatus_In& from);
  void MergeFrom(const StdCmds_GetStatus_In& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(StdCmds_GetStatus_In* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // @@protoc_insertion_point(class_scope:generated.zpb.hellomalif.StdCmds_GetStatus_In)
 private:
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_hellomalif_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class StdCmds_GetVersion_In : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:generated.zpb.hellomalif.StdCmds_GetVersion_In) */ {
 public:
  StdCmds_GetVersion_In();
  virtual ~StdCmds_GetVersion_In();
 
  StdCmds_GetVersion_In(const StdCmds_GetVersion_In& from);
 
  inline StdCmds_GetVersion_In& operator=(const StdCmds_GetVersion_In& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  StdCmds_GetVersion_In(StdCmds_GetVersion_In&& from) noexcept
    : StdCmds_GetVersion_In() {
    *this = ::std::move(from);
  }
 
  inline StdCmds_GetVersion_In& operator=(StdCmds_GetVersion_In&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const StdCmds_GetVersion_In& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const StdCmds_GetVersion_In* internal_default_instance() {
    return reinterpret_cast<const StdCmds_GetVersion_In*>(
               &_StdCmds_GetVersion_In_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;
 
  void Swap(StdCmds_GetVersion_In* other);
  friend void swap(StdCmds_GetVersion_In& a, StdCmds_GetVersion_In& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline StdCmds_GetVersion_In* New() const final {
    return CreateMaybeMessage<StdCmds_GetVersion_In>(NULL);
  }
 
  StdCmds_GetVersion_In* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<StdCmds_GetVersion_In>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const StdCmds_GetVersion_In& from);
  void MergeFrom(const StdCmds_GetVersion_In& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(StdCmds_GetVersion_In* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // @@protoc_insertion_point(class_scope:generated.zpb.hellomalif.StdCmds_GetVersion_In)
 private:
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_hellomalif_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class StdCmds_Stop_In : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:generated.zpb.hellomalif.StdCmds_Stop_In) */ {
 public:
  StdCmds_Stop_In();
  virtual ~StdCmds_Stop_In();
 
  StdCmds_Stop_In(const StdCmds_Stop_In& from);
 
  inline StdCmds_Stop_In& operator=(const StdCmds_Stop_In& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  StdCmds_Stop_In(StdCmds_Stop_In&& from) noexcept
    : StdCmds_Stop_In() {
    *this = ::std::move(from);
  }
 
  inline StdCmds_Stop_In& operator=(StdCmds_Stop_In&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const StdCmds_Stop_In& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const StdCmds_Stop_In* internal_default_instance() {
    return reinterpret_cast<const StdCmds_Stop_In*>(
               &_StdCmds_Stop_In_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;
 
  void Swap(StdCmds_Stop_In* other);
  friend void swap(StdCmds_Stop_In& a, StdCmds_Stop_In& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline StdCmds_Stop_In* New() const final {
    return CreateMaybeMessage<StdCmds_Stop_In>(NULL);
  }
 
  StdCmds_Stop_In* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<StdCmds_Stop_In>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const StdCmds_Stop_In& from);
  void MergeFrom(const StdCmds_Stop_In& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(StdCmds_Stop_In* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // @@protoc_insertion_point(class_scope:generated.zpb.hellomalif.StdCmds_Stop_In)
 private:
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_hellomalif_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class StdCmds_Exit_In : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:generated.zpb.hellomalif.StdCmds_Exit_In) */ {
 public:
  StdCmds_Exit_In();
  virtual ~StdCmds_Exit_In();
 
  StdCmds_Exit_In(const StdCmds_Exit_In& from);
 
  inline StdCmds_Exit_In& operator=(const StdCmds_Exit_In& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  StdCmds_Exit_In(StdCmds_Exit_In&& from) noexcept
    : StdCmds_Exit_In() {
    *this = ::std::move(from);
  }
 
  inline StdCmds_Exit_In& operator=(StdCmds_Exit_In&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const StdCmds_Exit_In& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const StdCmds_Exit_In* internal_default_instance() {
    return reinterpret_cast<const StdCmds_Exit_In*>(
               &_StdCmds_Exit_In_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    10;
 
  void Swap(StdCmds_Exit_In* other);
  friend void swap(StdCmds_Exit_In& a, StdCmds_Exit_In& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline StdCmds_Exit_In* New() const final {
    return CreateMaybeMessage<StdCmds_Exit_In>(NULL);
  }
 
  StdCmds_Exit_In* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<StdCmds_Exit_In>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const StdCmds_Exit_In& from);
  void MergeFrom(const StdCmds_Exit_In& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(StdCmds_Exit_In* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // @@protoc_insertion_point(class_scope:generated.zpb.hellomalif.StdCmds_Exit_In)
 private:
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_hellomalif_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class StdCmds_SetLogLevel_In : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:generated.zpb.hellomalif.StdCmds_SetLogLevel_In) */ {
 public:
  StdCmds_SetLogLevel_In();
  virtual ~StdCmds_SetLogLevel_In();
 
  StdCmds_SetLogLevel_In(const StdCmds_SetLogLevel_In& from);
 
  inline StdCmds_SetLogLevel_In& operator=(const StdCmds_SetLogLevel_In& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  StdCmds_SetLogLevel_In(StdCmds_SetLogLevel_In&& from) noexcept
    : StdCmds_SetLogLevel_In() {
    *this = ::std::move(from);
  }
 
  inline StdCmds_SetLogLevel_In& operator=(StdCmds_SetLogLevel_In&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const StdCmds_SetLogLevel_In& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const StdCmds_SetLogLevel_In* internal_default_instance() {
    return reinterpret_cast<const StdCmds_SetLogLevel_In*>(
               &_StdCmds_SetLogLevel_In_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    11;
 
  void Swap(StdCmds_SetLogLevel_In* other);
  friend void swap(StdCmds_SetLogLevel_In& a, StdCmds_SetLogLevel_In& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline StdCmds_SetLogLevel_In* New() const final {
    return CreateMaybeMessage<StdCmds_SetLogLevel_In>(NULL);
  }
 
  StdCmds_SetLogLevel_In* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<StdCmds_SetLogLevel_In>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const StdCmds_SetLogLevel_In& from);
  void MergeFrom(const StdCmds_SetLogLevel_In& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(StdCmds_SetLogLevel_In* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // required .generated.zpb.hellomalif.LogInfo info = 1;
  bool has_info() const;
  void clear_info();
  static const int kInfoFieldNumber = 1;
  private:
  const ::generated::zpb::hellomalif::LogInfo& _internal_info() const;
  public:
  const ::generated::zpb::hellomalif::LogInfo& info() const;
  ::generated::zpb::hellomalif::LogInfo* release_info();
  ::generated::zpb::hellomalif::LogInfo* mutable_info();
  void set_allocated_info(::generated::zpb::hellomalif::LogInfo* info);
 
  // @@protoc_insertion_point(class_scope:generated.zpb.hellomalif.StdCmds_SetLogLevel_In)
 private:
  void set_has_info();
  void clear_has_info();
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::generated::zpb::hellomalif::LogInfo* info_;
  friend struct ::protobuf_hellomalif_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class StdCmds_Call : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:generated.zpb.hellomalif.StdCmds_Call) */ {
 public:
  StdCmds_Call();
  virtual ~StdCmds_Call();
 
  StdCmds_Call(const StdCmds_Call& from);
 
  inline StdCmds_Call& operator=(const StdCmds_Call& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  StdCmds_Call(StdCmds_Call&& from) noexcept
    : StdCmds_Call() {
    *this = ::std::move(from);
  }
 
  inline StdCmds_Call& operator=(StdCmds_Call&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const StdCmds_Call& default_instance();
 
  enum RequestCase {
    kInit = 1,
    kReset = 2,
    kEnable = 3,
    kDisable = 4,
    kGetState = 5,
    kGetStatus = 6,
    kGetVersion = 7,
    kStop = 8,
    kExit = 9,
    kSetLogLevel = 10,
    REQUEST_NOT_SET = 0,
  };
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const StdCmds_Call* internal_default_instance() {
    return reinterpret_cast<const StdCmds_Call*>(
               &_StdCmds_Call_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    12;
 
  void Swap(StdCmds_Call* other);
  friend void swap(StdCmds_Call& a, StdCmds_Call& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline StdCmds_Call* New() const final {
    return CreateMaybeMessage<StdCmds_Call>(NULL);
  }
 
  StdCmds_Call* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<StdCmds_Call>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const StdCmds_Call& from);
  void MergeFrom(const StdCmds_Call& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(StdCmds_Call* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // optional .generated.zpb.hellomalif.StdCmds_Init_In Init = 1;
  bool has_init() const;
  void clear_init();
  static const int kInitFieldNumber = 1;
  private:
  const ::generated::zpb::hellomalif::StdCmds_Init_In& _internal_init() const;
  public:
  const ::generated::zpb::hellomalif::StdCmds_Init_In& init() const;
  ::generated::zpb::hellomalif::StdCmds_Init_In* release_init();
  ::generated::zpb::hellomalif::StdCmds_Init_In* mutable_init();
  void set_allocated_init(::generated::zpb::hellomalif::StdCmds_Init_In* init);
 
  // optional .generated.zpb.hellomalif.StdCmds_Reset_In Reset = 2;
  bool has_reset() const;
  void clear_reset();
  static const int kResetFieldNumber = 2;
  private:
  const ::generated::zpb::hellomalif::StdCmds_Reset_In& _internal_reset() const;
  public:
  const ::generated::zpb::hellomalif::StdCmds_Reset_In& reset() const;
  ::generated::zpb::hellomalif::StdCmds_Reset_In* release_reset();
  ::generated::zpb::hellomalif::StdCmds_Reset_In* mutable_reset();
  void set_allocated_reset(::generated::zpb::hellomalif::StdCmds_Reset_In* reset);
 
  // optional .generated.zpb.hellomalif.StdCmds_Enable_In Enable = 3;
  bool has_enable() const;
  void clear_enable();
  static const int kEnableFieldNumber = 3;
  private:
  const ::generated::zpb::hellomalif::StdCmds_Enable_In& _internal_enable() const;
  public:
  const ::generated::zpb::hellomalif::StdCmds_Enable_In& enable() const;
  ::generated::zpb::hellomalif::StdCmds_Enable_In* release_enable();
  ::generated::zpb::hellomalif::StdCmds_Enable_In* mutable_enable();
  void set_allocated_enable(::generated::zpb::hellomalif::StdCmds_Enable_In* enable);
 
  // optional .generated.zpb.hellomalif.StdCmds_Disable_In Disable = 4;
  bool has_disable() const;
  void clear_disable();
  static const int kDisableFieldNumber = 4;
  private:
  const ::generated::zpb::hellomalif::StdCmds_Disable_In& _internal_disable() const;
  public:
  const ::generated::zpb::hellomalif::StdCmds_Disable_In& disable() const;
  ::generated::zpb::hellomalif::StdCmds_Disable_In* release_disable();
  ::generated::zpb::hellomalif::StdCmds_Disable_In* mutable_disable();
  void set_allocated_disable(::generated::zpb::hellomalif::StdCmds_Disable_In* disable);
 
  // optional .generated.zpb.hellomalif.StdCmds_GetState_In GetState = 5;
  bool has_getstate() const;
  void clear_getstate();
  static const int kGetStateFieldNumber = 5;
  private:
  const ::generated::zpb::hellomalif::StdCmds_GetState_In& _internal_getstate() const;
  public:
  const ::generated::zpb::hellomalif::StdCmds_GetState_In& getstate() const;
  ::generated::zpb::hellomalif::StdCmds_GetState_In* release_getstate();
  ::generated::zpb::hellomalif::StdCmds_GetState_In* mutable_getstate();
  void set_allocated_getstate(::generated::zpb::hellomalif::StdCmds_GetState_In* getstate);
 
  // optional .generated.zpb.hellomalif.StdCmds_GetStatus_In GetStatus = 6;
  bool has_getstatus() const;
  void clear_getstatus();
  static const int kGetStatusFieldNumber = 6;
  private:
  const ::generated::zpb::hellomalif::StdCmds_GetStatus_In& _internal_getstatus() const;
  public:
  const ::generated::zpb::hellomalif::StdCmds_GetStatus_In& getstatus() const;
  ::generated::zpb::hellomalif::StdCmds_GetStatus_In* release_getstatus();
  ::generated::zpb::hellomalif::StdCmds_GetStatus_In* mutable_getstatus();
  void set_allocated_getstatus(::generated::zpb::hellomalif::StdCmds_GetStatus_In* getstatus);
 
  // optional .generated.zpb.hellomalif.StdCmds_GetVersion_In GetVersion = 7;
  bool has_getversion() const;
  void clear_getversion();
  static const int kGetVersionFieldNumber = 7;
  private:
  const ::generated::zpb::hellomalif::StdCmds_GetVersion_In& _internal_getversion() const;
  public:
  const ::generated::zpb::hellomalif::StdCmds_GetVersion_In& getversion() const;
  ::generated::zpb::hellomalif::StdCmds_GetVersion_In* release_getversion();
  ::generated::zpb::hellomalif::StdCmds_GetVersion_In* mutable_getversion();
  void set_allocated_getversion(::generated::zpb::hellomalif::StdCmds_GetVersion_In* getversion);
 
  // optional .generated.zpb.hellomalif.StdCmds_Stop_In Stop = 8;
  bool has_stop() const;
  void clear_stop();
  static const int kStopFieldNumber = 8;
  private:
  const ::generated::zpb::hellomalif::StdCmds_Stop_In& _internal_stop() const;
  public:
  const ::generated::zpb::hellomalif::StdCmds_Stop_In& stop() const;
  ::generated::zpb::hellomalif::StdCmds_Stop_In* release_stop();
  ::generated::zpb::hellomalif::StdCmds_Stop_In* mutable_stop();
  void set_allocated_stop(::generated::zpb::hellomalif::StdCmds_Stop_In* stop);
 
  // optional .generated.zpb.hellomalif.StdCmds_Exit_In Exit = 9;
  bool has_exit() const;
  void clear_exit();
  static const int kExitFieldNumber = 9;
  private:
  const ::generated::zpb::hellomalif::StdCmds_Exit_In& _internal_exit() const;
  public:
  const ::generated::zpb::hellomalif::StdCmds_Exit_In& exit() const;
  ::generated::zpb::hellomalif::StdCmds_Exit_In* release_exit();
  ::generated::zpb::hellomalif::StdCmds_Exit_In* mutable_exit();
  void set_allocated_exit(::generated::zpb::hellomalif::StdCmds_Exit_In* exit);
 
  // optional .generated.zpb.hellomalif.StdCmds_SetLogLevel_In SetLogLevel = 10;
  bool has_setloglevel() const;
  void clear_setloglevel();
  static const int kSetLogLevelFieldNumber = 10;
  private:
  const ::generated::zpb::hellomalif::StdCmds_SetLogLevel_In& _internal_setloglevel() const;
  public:
  const ::generated::zpb::hellomalif::StdCmds_SetLogLevel_In& setloglevel() const;
  ::generated::zpb::hellomalif::StdCmds_SetLogLevel_In* release_setloglevel();
  ::generated::zpb::hellomalif::StdCmds_SetLogLevel_In* mutable_setloglevel();
  void set_allocated_setloglevel(::generated::zpb::hellomalif::StdCmds_SetLogLevel_In* setloglevel);
 
  void clear_request();
  RequestCase request_case() const;
  // @@protoc_insertion_point(class_scope:generated.zpb.hellomalif.StdCmds_Call)
 private:
  void set_has_init();
  void set_has_reset();
  void set_has_enable();
  void set_has_disable();
  void set_has_getstate();
  void set_has_getstatus();
  void set_has_getversion();
  void set_has_stop();
  void set_has_exit();
  void set_has_setloglevel();
 
  inline bool has_request() const;
  inline void clear_has_request();
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  union RequestUnion {
    RequestUnion() {}
    ::generated::zpb::hellomalif::StdCmds_Init_In* init_;
    ::generated::zpb::hellomalif::StdCmds_Reset_In* reset_;
    ::generated::zpb::hellomalif::StdCmds_Enable_In* enable_;
    ::generated::zpb::hellomalif::StdCmds_Disable_In* disable_;
    ::generated::zpb::hellomalif::StdCmds_GetState_In* getstate_;
    ::generated::zpb::hellomalif::StdCmds_GetStatus_In* getstatus_;
    ::generated::zpb::hellomalif::StdCmds_GetVersion_In* getversion_;
    ::generated::zpb::hellomalif::StdCmds_Stop_In* stop_;
    ::generated::zpb::hellomalif::StdCmds_Exit_In* exit_;
    ::generated::zpb::hellomalif::StdCmds_SetLogLevel_In* setloglevel_;
  } request_;
  ::google::protobuf::uint32 _oneof_case_[1];
 
  friend struct ::protobuf_hellomalif_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class StdCmds_Request : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:generated.zpb.hellomalif.StdCmds_Request) */ {
 public:
  StdCmds_Request();
  virtual ~StdCmds_Request();
 
  StdCmds_Request(const StdCmds_Request& from);
 
  inline StdCmds_Request& operator=(const StdCmds_Request& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  StdCmds_Request(StdCmds_Request&& from) noexcept
    : StdCmds_Request() {
    *this = ::std::move(from);
  }
 
  inline StdCmds_Request& operator=(StdCmds_Request&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const StdCmds_Request& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const StdCmds_Request* internal_default_instance() {
    return reinterpret_cast<const StdCmds_Request*>(
               &_StdCmds_Request_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    13;
 
  void Swap(StdCmds_Request* other);
  friend void swap(StdCmds_Request& a, StdCmds_Request& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline StdCmds_Request* New() const final {
    return CreateMaybeMessage<StdCmds_Request>(NULL);
  }
 
  StdCmds_Request* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<StdCmds_Request>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const StdCmds_Request& from);
  void MergeFrom(const StdCmds_Request& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(StdCmds_Request* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // required .elt.mal.zpb.rr.RequestHeader header = 1;
  bool has_header() const;
  void clear_header();
  static const int kHeaderFieldNumber = 1;
  private:
  const ::elt::mal::zpb::rr::RequestHeader& _internal_header() const;
  public:
  const ::elt::mal::zpb::rr::RequestHeader& header() const;
  ::elt::mal::zpb::rr::RequestHeader* release_header();
  ::elt::mal::zpb::rr::RequestHeader* mutable_header();
  void set_allocated_header(::elt::mal::zpb::rr::RequestHeader* header);
 
  // required .generated.zpb.hellomalif.StdCmds_Call data = 2;
  bool has_data() const;
  void clear_data();
  static const int kDataFieldNumber = 2;
  private:
  const ::generated::zpb::hellomalif::StdCmds_Call& _internal_data() const;
  public:
  const ::generated::zpb::hellomalif::StdCmds_Call& data() const;
  ::generated::zpb::hellomalif::StdCmds_Call* release_data();
  ::generated::zpb::hellomalif::StdCmds_Call* mutable_data();
  void set_allocated_data(::generated::zpb::hellomalif::StdCmds_Call* data);
 
  // @@protoc_insertion_point(class_scope:generated.zpb.hellomalif.StdCmds_Request)
 private:
  void set_has_header();
  void clear_has_header();
  void set_has_data();
  void clear_has_data();
 
  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::elt::mal::zpb::rr::RequestHeader* header_;
  ::generated::zpb::hellomalif::StdCmds_Call* data_;
  friend struct ::protobuf_hellomalif_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class StdCmds_Init_Out : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:generated.zpb.hellomalif.StdCmds_Init_Out) */ {
 public:
  StdCmds_Init_Out();
  virtual ~StdCmds_Init_Out();
 
  StdCmds_Init_Out(const StdCmds_Init_Out& from);
 
  inline StdCmds_Init_Out& operator=(const StdCmds_Init_Out& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  StdCmds_Init_Out(StdCmds_Init_Out&& from) noexcept
    : StdCmds_Init_Out() {
    *this = ::std::move(from);
  }
 
  inline StdCmds_Init_Out& operator=(StdCmds_Init_Out&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const StdCmds_Init_Out& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const StdCmds_Init_Out* internal_default_instance() {
    return reinterpret_cast<const StdCmds_Init_Out*>(
               &_StdCmds_Init_Out_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    14;
 
  void Swap(StdCmds_Init_Out* other);
  friend void swap(StdCmds_Init_Out& a, StdCmds_Init_Out& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline StdCmds_Init_Out* New() const final {
    return CreateMaybeMessage<StdCmds_Init_Out>(NULL);
  }
 
  StdCmds_Init_Out* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<StdCmds_Init_Out>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const StdCmds_Init_Out& from);
  void MergeFrom(const StdCmds_Init_Out& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(StdCmds_Init_Out* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // optional string retval = 1;
  bool has_retval() const;
  void clear_retval();
  static const int kRetvalFieldNumber = 1;
  const ::std::string& retval() const;
  void set_retval(const ::std::string& value);
  #if LANG_CXX11
  void set_retval(::std::string&& value);
  #endif
  void set_retval(const char* value);
  void set_retval(const char* value, size_t size);
  ::std::string* mutable_retval();
  ::std::string* release_retval();
  void set_allocated_retval(::std::string* retval);
 
  // optional .generated.zpb.hellomalif.ExceptionErr exExceptionErr = 2;
  bool has_exexceptionerr() const;
  void clear_exexceptionerr();
  static const int kExExceptionErrFieldNumber = 2;
  private:
  const ::generated::zpb::hellomalif::ExceptionErr& _internal_exexceptionerr() const;
  public:
  const ::generated::zpb::hellomalif::ExceptionErr& exexceptionerr() const;
  ::generated::zpb::hellomalif::ExceptionErr* release_exexceptionerr();
  ::generated::zpb::hellomalif::ExceptionErr* mutable_exexceptionerr();
  void set_allocated_exexceptionerr(::generated::zpb::hellomalif::ExceptionErr* exexceptionerr);
 
  // @@protoc_insertion_point(class_scope:generated.zpb.hellomalif.StdCmds_Init_Out)
 private:
  void set_has_retval();
  void clear_has_retval();
  void set_has_exexceptionerr();
  void clear_has_exexceptionerr();
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr retval_;
  ::generated::zpb::hellomalif::ExceptionErr* exexceptionerr_;
  friend struct ::protobuf_hellomalif_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class StdCmds_Reset_Out : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:generated.zpb.hellomalif.StdCmds_Reset_Out) */ {
 public:
  StdCmds_Reset_Out();
  virtual ~StdCmds_Reset_Out();
 
  StdCmds_Reset_Out(const StdCmds_Reset_Out& from);
 
  inline StdCmds_Reset_Out& operator=(const StdCmds_Reset_Out& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  StdCmds_Reset_Out(StdCmds_Reset_Out&& from) noexcept
    : StdCmds_Reset_Out() {
    *this = ::std::move(from);
  }
 
  inline StdCmds_Reset_Out& operator=(StdCmds_Reset_Out&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const StdCmds_Reset_Out& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const StdCmds_Reset_Out* internal_default_instance() {
    return reinterpret_cast<const StdCmds_Reset_Out*>(
               &_StdCmds_Reset_Out_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    15;
 
  void Swap(StdCmds_Reset_Out* other);
  friend void swap(StdCmds_Reset_Out& a, StdCmds_Reset_Out& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline StdCmds_Reset_Out* New() const final {
    return CreateMaybeMessage<StdCmds_Reset_Out>(NULL);
  }
 
  StdCmds_Reset_Out* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<StdCmds_Reset_Out>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const StdCmds_Reset_Out& from);
  void MergeFrom(const StdCmds_Reset_Out& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(StdCmds_Reset_Out* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // optional string retval = 1;
  bool has_retval() const;
  void clear_retval();
  static const int kRetvalFieldNumber = 1;
  const ::std::string& retval() const;
  void set_retval(const ::std::string& value);
  #if LANG_CXX11
  void set_retval(::std::string&& value);
  #endif
  void set_retval(const char* value);
  void set_retval(const char* value, size_t size);
  ::std::string* mutable_retval();
  ::std::string* release_retval();
  void set_allocated_retval(::std::string* retval);
 
  // optional .generated.zpb.hellomalif.ExceptionErr exExceptionErr = 2;
  bool has_exexceptionerr() const;
  void clear_exexceptionerr();
  static const int kExExceptionErrFieldNumber = 2;
  private:
  const ::generated::zpb::hellomalif::ExceptionErr& _internal_exexceptionerr() const;
  public:
  const ::generated::zpb::hellomalif::ExceptionErr& exexceptionerr() const;
  ::generated::zpb::hellomalif::ExceptionErr* release_exexceptionerr();
  ::generated::zpb::hellomalif::ExceptionErr* mutable_exexceptionerr();
  void set_allocated_exexceptionerr(::generated::zpb::hellomalif::ExceptionErr* exexceptionerr);
 
  // @@protoc_insertion_point(class_scope:generated.zpb.hellomalif.StdCmds_Reset_Out)
 private:
  void set_has_retval();
  void clear_has_retval();
  void set_has_exexceptionerr();
  void clear_has_exexceptionerr();
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr retval_;
  ::generated::zpb::hellomalif::ExceptionErr* exexceptionerr_;
  friend struct ::protobuf_hellomalif_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class StdCmds_Enable_Out : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:generated.zpb.hellomalif.StdCmds_Enable_Out) */ {
 public:
  StdCmds_Enable_Out();
  virtual ~StdCmds_Enable_Out();
 
  StdCmds_Enable_Out(const StdCmds_Enable_Out& from);
 
  inline StdCmds_Enable_Out& operator=(const StdCmds_Enable_Out& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  StdCmds_Enable_Out(StdCmds_Enable_Out&& from) noexcept
    : StdCmds_Enable_Out() {
    *this = ::std::move(from);
  }
 
  inline StdCmds_Enable_Out& operator=(StdCmds_Enable_Out&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const StdCmds_Enable_Out& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const StdCmds_Enable_Out* internal_default_instance() {
    return reinterpret_cast<const StdCmds_Enable_Out*>(
               &_StdCmds_Enable_Out_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    16;
 
  void Swap(StdCmds_Enable_Out* other);
  friend void swap(StdCmds_Enable_Out& a, StdCmds_Enable_Out& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline StdCmds_Enable_Out* New() const final {
    return CreateMaybeMessage<StdCmds_Enable_Out>(NULL);
  }
 
  StdCmds_Enable_Out* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<StdCmds_Enable_Out>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const StdCmds_Enable_Out& from);
  void MergeFrom(const StdCmds_Enable_Out& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(StdCmds_Enable_Out* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // optional string retval = 1;
  bool has_retval() const;
  void clear_retval();
  static const int kRetvalFieldNumber = 1;
  const ::std::string& retval() const;
  void set_retval(const ::std::string& value);
  #if LANG_CXX11
  void set_retval(::std::string&& value);
  #endif
  void set_retval(const char* value);
  void set_retval(const char* value, size_t size);
  ::std::string* mutable_retval();
  ::std::string* release_retval();
  void set_allocated_retval(::std::string* retval);
 
  // optional .generated.zpb.hellomalif.ExceptionErr exExceptionErr = 2;
  bool has_exexceptionerr() const;
  void clear_exexceptionerr();
  static const int kExExceptionErrFieldNumber = 2;
  private:
  const ::generated::zpb::hellomalif::ExceptionErr& _internal_exexceptionerr() const;
  public:
  const ::generated::zpb::hellomalif::ExceptionErr& exexceptionerr() const;
  ::generated::zpb::hellomalif::ExceptionErr* release_exexceptionerr();
  ::generated::zpb::hellomalif::ExceptionErr* mutable_exexceptionerr();
  void set_allocated_exexceptionerr(::generated::zpb::hellomalif::ExceptionErr* exexceptionerr);
 
  // @@protoc_insertion_point(class_scope:generated.zpb.hellomalif.StdCmds_Enable_Out)
 private:
  void set_has_retval();
  void clear_has_retval();
  void set_has_exexceptionerr();
  void clear_has_exexceptionerr();
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr retval_;
  ::generated::zpb::hellomalif::ExceptionErr* exexceptionerr_;
  friend struct ::protobuf_hellomalif_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class StdCmds_Disable_Out : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:generated.zpb.hellomalif.StdCmds_Disable_Out) */ {
 public:
  StdCmds_Disable_Out();
  virtual ~StdCmds_Disable_Out();
 
  StdCmds_Disable_Out(const StdCmds_Disable_Out& from);
 
  inline StdCmds_Disable_Out& operator=(const StdCmds_Disable_Out& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  StdCmds_Disable_Out(StdCmds_Disable_Out&& from) noexcept
    : StdCmds_Disable_Out() {
    *this = ::std::move(from);
  }
 
  inline StdCmds_Disable_Out& operator=(StdCmds_Disable_Out&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const StdCmds_Disable_Out& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const StdCmds_Disable_Out* internal_default_instance() {
    return reinterpret_cast<const StdCmds_Disable_Out*>(
               &_StdCmds_Disable_Out_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    17;
 
  void Swap(StdCmds_Disable_Out* other);
  friend void swap(StdCmds_Disable_Out& a, StdCmds_Disable_Out& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline StdCmds_Disable_Out* New() const final {
    return CreateMaybeMessage<StdCmds_Disable_Out>(NULL);
  }
 
  StdCmds_Disable_Out* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<StdCmds_Disable_Out>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const StdCmds_Disable_Out& from);
  void MergeFrom(const StdCmds_Disable_Out& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(StdCmds_Disable_Out* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // optional string retval = 1;
  bool has_retval() const;
  void clear_retval();
  static const int kRetvalFieldNumber = 1;
  const ::std::string& retval() const;
  void set_retval(const ::std::string& value);
  #if LANG_CXX11
  void set_retval(::std::string&& value);
  #endif
  void set_retval(const char* value);
  void set_retval(const char* value, size_t size);
  ::std::string* mutable_retval();
  ::std::string* release_retval();
  void set_allocated_retval(::std::string* retval);
 
  // optional .generated.zpb.hellomalif.ExceptionErr exExceptionErr = 2;
  bool has_exexceptionerr() const;
  void clear_exexceptionerr();
  static const int kExExceptionErrFieldNumber = 2;
  private:
  const ::generated::zpb::hellomalif::ExceptionErr& _internal_exexceptionerr() const;
  public:
  const ::generated::zpb::hellomalif::ExceptionErr& exexceptionerr() const;
  ::generated::zpb::hellomalif::ExceptionErr* release_exexceptionerr();
  ::generated::zpb::hellomalif::ExceptionErr* mutable_exexceptionerr();
  void set_allocated_exexceptionerr(::generated::zpb::hellomalif::ExceptionErr* exexceptionerr);
 
  // @@protoc_insertion_point(class_scope:generated.zpb.hellomalif.StdCmds_Disable_Out)
 private:
  void set_has_retval();
  void clear_has_retval();
  void set_has_exexceptionerr();
  void clear_has_exexceptionerr();
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr retval_;
  ::generated::zpb::hellomalif::ExceptionErr* exexceptionerr_;
  friend struct ::protobuf_hellomalif_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class StdCmds_GetState_Out : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:generated.zpb.hellomalif.StdCmds_GetState_Out) */ {
 public:
  StdCmds_GetState_Out();
  virtual ~StdCmds_GetState_Out();
 
  StdCmds_GetState_Out(const StdCmds_GetState_Out& from);
 
  inline StdCmds_GetState_Out& operator=(const StdCmds_GetState_Out& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  StdCmds_GetState_Out(StdCmds_GetState_Out&& from) noexcept
    : StdCmds_GetState_Out() {
    *this = ::std::move(from);
  }
 
  inline StdCmds_GetState_Out& operator=(StdCmds_GetState_Out&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const StdCmds_GetState_Out& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const StdCmds_GetState_Out* internal_default_instance() {
    return reinterpret_cast<const StdCmds_GetState_Out*>(
               &_StdCmds_GetState_Out_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    18;
 
  void Swap(StdCmds_GetState_Out* other);
  friend void swap(StdCmds_GetState_Out& a, StdCmds_GetState_Out& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline StdCmds_GetState_Out* New() const final {
    return CreateMaybeMessage<StdCmds_GetState_Out>(NULL);
  }
 
  StdCmds_GetState_Out* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<StdCmds_GetState_Out>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const StdCmds_GetState_Out& from);
  void MergeFrom(const StdCmds_GetState_Out& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(StdCmds_GetState_Out* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // optional string retval = 1;
  bool has_retval() const;
  void clear_retval();
  static const int kRetvalFieldNumber = 1;
  const ::std::string& retval() const;
  void set_retval(const ::std::string& value);
  #if LANG_CXX11
  void set_retval(::std::string&& value);
  #endif
  void set_retval(const char* value);
  void set_retval(const char* value, size_t size);
  ::std::string* mutable_retval();
  ::std::string* release_retval();
  void set_allocated_retval(::std::string* retval);
 
  // optional .generated.zpb.hellomalif.ExceptionErr exExceptionErr = 2;
  bool has_exexceptionerr() const;
  void clear_exexceptionerr();
  static const int kExExceptionErrFieldNumber = 2;
  private:
  const ::generated::zpb::hellomalif::ExceptionErr& _internal_exexceptionerr() const;
  public:
  const ::generated::zpb::hellomalif::ExceptionErr& exexceptionerr() const;
  ::generated::zpb::hellomalif::ExceptionErr* release_exexceptionerr();
  ::generated::zpb::hellomalif::ExceptionErr* mutable_exexceptionerr();
  void set_allocated_exexceptionerr(::generated::zpb::hellomalif::ExceptionErr* exexceptionerr);
 
  // @@protoc_insertion_point(class_scope:generated.zpb.hellomalif.StdCmds_GetState_Out)
 private:
  void set_has_retval();
  void clear_has_retval();
  void set_has_exexceptionerr();
  void clear_has_exexceptionerr();
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr retval_;
  ::generated::zpb::hellomalif::ExceptionErr* exexceptionerr_;
  friend struct ::protobuf_hellomalif_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class StdCmds_GetStatus_Out : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:generated.zpb.hellomalif.StdCmds_GetStatus_Out) */ {
 public:
  StdCmds_GetStatus_Out();
  virtual ~StdCmds_GetStatus_Out();
 
  StdCmds_GetStatus_Out(const StdCmds_GetStatus_Out& from);
 
  inline StdCmds_GetStatus_Out& operator=(const StdCmds_GetStatus_Out& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  StdCmds_GetStatus_Out(StdCmds_GetStatus_Out&& from) noexcept
    : StdCmds_GetStatus_Out() {
    *this = ::std::move(from);
  }
 
  inline StdCmds_GetStatus_Out& operator=(StdCmds_GetStatus_Out&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const StdCmds_GetStatus_Out& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const StdCmds_GetStatus_Out* internal_default_instance() {
    return reinterpret_cast<const StdCmds_GetStatus_Out*>(
               &_StdCmds_GetStatus_Out_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    19;
 
  void Swap(StdCmds_GetStatus_Out* other);
  friend void swap(StdCmds_GetStatus_Out& a, StdCmds_GetStatus_Out& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline StdCmds_GetStatus_Out* New() const final {
    return CreateMaybeMessage<StdCmds_GetStatus_Out>(NULL);
  }
 
  StdCmds_GetStatus_Out* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<StdCmds_GetStatus_Out>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const StdCmds_GetStatus_Out& from);
  void MergeFrom(const StdCmds_GetStatus_Out& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(StdCmds_GetStatus_Out* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // optional string retval = 1;
  bool has_retval() const;
  void clear_retval();
  static const int kRetvalFieldNumber = 1;
  const ::std::string& retval() const;
  void set_retval(const ::std::string& value);
  #if LANG_CXX11
  void set_retval(::std::string&& value);
  #endif
  void set_retval(const char* value);
  void set_retval(const char* value, size_t size);
  ::std::string* mutable_retval();
  ::std::string* release_retval();
  void set_allocated_retval(::std::string* retval);
 
  // optional .generated.zpb.hellomalif.ExceptionErr exExceptionErr = 2;
  bool has_exexceptionerr() const;
  void clear_exexceptionerr();
  static const int kExExceptionErrFieldNumber = 2;
  private:
  const ::generated::zpb::hellomalif::ExceptionErr& _internal_exexceptionerr() const;
  public:
  const ::generated::zpb::hellomalif::ExceptionErr& exexceptionerr() const;
  ::generated::zpb::hellomalif::ExceptionErr* release_exexceptionerr();
  ::generated::zpb::hellomalif::ExceptionErr* mutable_exexceptionerr();
  void set_allocated_exexceptionerr(::generated::zpb::hellomalif::ExceptionErr* exexceptionerr);
 
  // @@protoc_insertion_point(class_scope:generated.zpb.hellomalif.StdCmds_GetStatus_Out)
 private:
  void set_has_retval();
  void clear_has_retval();
  void set_has_exexceptionerr();
  void clear_has_exexceptionerr();
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr retval_;
  ::generated::zpb::hellomalif::ExceptionErr* exexceptionerr_;
  friend struct ::protobuf_hellomalif_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class StdCmds_GetVersion_Out : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:generated.zpb.hellomalif.StdCmds_GetVersion_Out) */ {
 public:
  StdCmds_GetVersion_Out();
  virtual ~StdCmds_GetVersion_Out();
 
  StdCmds_GetVersion_Out(const StdCmds_GetVersion_Out& from);
 
  inline StdCmds_GetVersion_Out& operator=(const StdCmds_GetVersion_Out& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  StdCmds_GetVersion_Out(StdCmds_GetVersion_Out&& from) noexcept
    : StdCmds_GetVersion_Out() {
    *this = ::std::move(from);
  }
 
  inline StdCmds_GetVersion_Out& operator=(StdCmds_GetVersion_Out&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const StdCmds_GetVersion_Out& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const StdCmds_GetVersion_Out* internal_default_instance() {
    return reinterpret_cast<const StdCmds_GetVersion_Out*>(
               &_StdCmds_GetVersion_Out_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    20;
 
  void Swap(StdCmds_GetVersion_Out* other);
  friend void swap(StdCmds_GetVersion_Out& a, StdCmds_GetVersion_Out& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline StdCmds_GetVersion_Out* New() const final {
    return CreateMaybeMessage<StdCmds_GetVersion_Out>(NULL);
  }
 
  StdCmds_GetVersion_Out* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<StdCmds_GetVersion_Out>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const StdCmds_GetVersion_Out& from);
  void MergeFrom(const StdCmds_GetVersion_Out& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(StdCmds_GetVersion_Out* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // optional string retval = 1;
  bool has_retval() const;
  void clear_retval();
  static const int kRetvalFieldNumber = 1;
  const ::std::string& retval() const;
  void set_retval(const ::std::string& value);
  #if LANG_CXX11
  void set_retval(::std::string&& value);
  #endif
  void set_retval(const char* value);
  void set_retval(const char* value, size_t size);
  ::std::string* mutable_retval();
  ::std::string* release_retval();
  void set_allocated_retval(::std::string* retval);
 
  // optional .generated.zpb.hellomalif.ExceptionErr exExceptionErr = 2;
  bool has_exexceptionerr() const;
  void clear_exexceptionerr();
  static const int kExExceptionErrFieldNumber = 2;
  private:
  const ::generated::zpb::hellomalif::ExceptionErr& _internal_exexceptionerr() const;
  public:
  const ::generated::zpb::hellomalif::ExceptionErr& exexceptionerr() const;
  ::generated::zpb::hellomalif::ExceptionErr* release_exexceptionerr();
  ::generated::zpb::hellomalif::ExceptionErr* mutable_exexceptionerr();
  void set_allocated_exexceptionerr(::generated::zpb::hellomalif::ExceptionErr* exexceptionerr);
 
  // @@protoc_insertion_point(class_scope:generated.zpb.hellomalif.StdCmds_GetVersion_Out)
 private:
  void set_has_retval();
  void clear_has_retval();
  void set_has_exexceptionerr();
  void clear_has_exexceptionerr();
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr retval_;
  ::generated::zpb::hellomalif::ExceptionErr* exexceptionerr_;
  friend struct ::protobuf_hellomalif_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class StdCmds_Stop_Out : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:generated.zpb.hellomalif.StdCmds_Stop_Out) */ {
 public:
  StdCmds_Stop_Out();
  virtual ~StdCmds_Stop_Out();
 
  StdCmds_Stop_Out(const StdCmds_Stop_Out& from);
 
  inline StdCmds_Stop_Out& operator=(const StdCmds_Stop_Out& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  StdCmds_Stop_Out(StdCmds_Stop_Out&& from) noexcept
    : StdCmds_Stop_Out() {
    *this = ::std::move(from);
  }
 
  inline StdCmds_Stop_Out& operator=(StdCmds_Stop_Out&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const StdCmds_Stop_Out& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const StdCmds_Stop_Out* internal_default_instance() {
    return reinterpret_cast<const StdCmds_Stop_Out*>(
               &_StdCmds_Stop_Out_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    21;
 
  void Swap(StdCmds_Stop_Out* other);
  friend void swap(StdCmds_Stop_Out& a, StdCmds_Stop_Out& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline StdCmds_Stop_Out* New() const final {
    return CreateMaybeMessage<StdCmds_Stop_Out>(NULL);
  }
 
  StdCmds_Stop_Out* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<StdCmds_Stop_Out>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const StdCmds_Stop_Out& from);
  void MergeFrom(const StdCmds_Stop_Out& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(StdCmds_Stop_Out* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // optional string retval = 1;
  bool has_retval() const;
  void clear_retval();
  static const int kRetvalFieldNumber = 1;
  const ::std::string& retval() const;
  void set_retval(const ::std::string& value);
  #if LANG_CXX11
  void set_retval(::std::string&& value);
  #endif
  void set_retval(const char* value);
  void set_retval(const char* value, size_t size);
  ::std::string* mutable_retval();
  ::std::string* release_retval();
  void set_allocated_retval(::std::string* retval);
 
  // optional .generated.zpb.hellomalif.ExceptionErr exExceptionErr = 2;
  bool has_exexceptionerr() const;
  void clear_exexceptionerr();
  static const int kExExceptionErrFieldNumber = 2;
  private:
  const ::generated::zpb::hellomalif::ExceptionErr& _internal_exexceptionerr() const;
  public:
  const ::generated::zpb::hellomalif::ExceptionErr& exexceptionerr() const;
  ::generated::zpb::hellomalif::ExceptionErr* release_exexceptionerr();
  ::generated::zpb::hellomalif::ExceptionErr* mutable_exexceptionerr();
  void set_allocated_exexceptionerr(::generated::zpb::hellomalif::ExceptionErr* exexceptionerr);
 
  // @@protoc_insertion_point(class_scope:generated.zpb.hellomalif.StdCmds_Stop_Out)
 private:
  void set_has_retval();
  void clear_has_retval();
  void set_has_exexceptionerr();
  void clear_has_exexceptionerr();
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr retval_;
  ::generated::zpb::hellomalif::ExceptionErr* exexceptionerr_;
  friend struct ::protobuf_hellomalif_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class StdCmds_Exit_Out : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:generated.zpb.hellomalif.StdCmds_Exit_Out) */ {
 public:
  StdCmds_Exit_Out();
  virtual ~StdCmds_Exit_Out();
 
  StdCmds_Exit_Out(const StdCmds_Exit_Out& from);
 
  inline StdCmds_Exit_Out& operator=(const StdCmds_Exit_Out& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  StdCmds_Exit_Out(StdCmds_Exit_Out&& from) noexcept
    : StdCmds_Exit_Out() {
    *this = ::std::move(from);
  }
 
  inline StdCmds_Exit_Out& operator=(StdCmds_Exit_Out&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const StdCmds_Exit_Out& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const StdCmds_Exit_Out* internal_default_instance() {
    return reinterpret_cast<const StdCmds_Exit_Out*>(
               &_StdCmds_Exit_Out_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    22;
 
  void Swap(StdCmds_Exit_Out* other);
  friend void swap(StdCmds_Exit_Out& a, StdCmds_Exit_Out& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline StdCmds_Exit_Out* New() const final {
    return CreateMaybeMessage<StdCmds_Exit_Out>(NULL);
  }
 
  StdCmds_Exit_Out* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<StdCmds_Exit_Out>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const StdCmds_Exit_Out& from);
  void MergeFrom(const StdCmds_Exit_Out& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(StdCmds_Exit_Out* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // optional string retval = 1;
  bool has_retval() const;
  void clear_retval();
  static const int kRetvalFieldNumber = 1;
  const ::std::string& retval() const;
  void set_retval(const ::std::string& value);
  #if LANG_CXX11
  void set_retval(::std::string&& value);
  #endif
  void set_retval(const char* value);
  void set_retval(const char* value, size_t size);
  ::std::string* mutable_retval();
  ::std::string* release_retval();
  void set_allocated_retval(::std::string* retval);
 
  // optional .generated.zpb.hellomalif.ExceptionErr exExceptionErr = 2;
  bool has_exexceptionerr() const;
  void clear_exexceptionerr();
  static const int kExExceptionErrFieldNumber = 2;
  private:
  const ::generated::zpb::hellomalif::ExceptionErr& _internal_exexceptionerr() const;
  public:
  const ::generated::zpb::hellomalif::ExceptionErr& exexceptionerr() const;
  ::generated::zpb::hellomalif::ExceptionErr* release_exexceptionerr();
  ::generated::zpb::hellomalif::ExceptionErr* mutable_exexceptionerr();
  void set_allocated_exexceptionerr(::generated::zpb::hellomalif::ExceptionErr* exexceptionerr);
 
  // @@protoc_insertion_point(class_scope:generated.zpb.hellomalif.StdCmds_Exit_Out)
 private:
  void set_has_retval();
  void clear_has_retval();
  void set_has_exexceptionerr();
  void clear_has_exexceptionerr();
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr retval_;
  ::generated::zpb::hellomalif::ExceptionErr* exexceptionerr_;
  friend struct ::protobuf_hellomalif_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class StdCmds_SetLogLevel_Out : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:generated.zpb.hellomalif.StdCmds_SetLogLevel_Out) */ {
 public:
  StdCmds_SetLogLevel_Out();
  virtual ~StdCmds_SetLogLevel_Out();
 
  StdCmds_SetLogLevel_Out(const StdCmds_SetLogLevel_Out& from);
 
  inline StdCmds_SetLogLevel_Out& operator=(const StdCmds_SetLogLevel_Out& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  StdCmds_SetLogLevel_Out(StdCmds_SetLogLevel_Out&& from) noexcept
    : StdCmds_SetLogLevel_Out() {
    *this = ::std::move(from);
  }
 
  inline StdCmds_SetLogLevel_Out& operator=(StdCmds_SetLogLevel_Out&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const StdCmds_SetLogLevel_Out& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const StdCmds_SetLogLevel_Out* internal_default_instance() {
    return reinterpret_cast<const StdCmds_SetLogLevel_Out*>(
               &_StdCmds_SetLogLevel_Out_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    23;
 
  void Swap(StdCmds_SetLogLevel_Out* other);
  friend void swap(StdCmds_SetLogLevel_Out& a, StdCmds_SetLogLevel_Out& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline StdCmds_SetLogLevel_Out* New() const final {
    return CreateMaybeMessage<StdCmds_SetLogLevel_Out>(NULL);
  }
 
  StdCmds_SetLogLevel_Out* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<StdCmds_SetLogLevel_Out>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const StdCmds_SetLogLevel_Out& from);
  void MergeFrom(const StdCmds_SetLogLevel_Out& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(StdCmds_SetLogLevel_Out* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // optional string retval = 1;
  bool has_retval() const;
  void clear_retval();
  static const int kRetvalFieldNumber = 1;
  const ::std::string& retval() const;
  void set_retval(const ::std::string& value);
  #if LANG_CXX11
  void set_retval(::std::string&& value);
  #endif
  void set_retval(const char* value);
  void set_retval(const char* value, size_t size);
  ::std::string* mutable_retval();
  ::std::string* release_retval();
  void set_allocated_retval(::std::string* retval);
 
  // optional .generated.zpb.hellomalif.ExceptionErr exExceptionErr = 2;
  bool has_exexceptionerr() const;
  void clear_exexceptionerr();
  static const int kExExceptionErrFieldNumber = 2;
  private:
  const ::generated::zpb::hellomalif::ExceptionErr& _internal_exexceptionerr() const;
  public:
  const ::generated::zpb::hellomalif::ExceptionErr& exexceptionerr() const;
  ::generated::zpb::hellomalif::ExceptionErr* release_exexceptionerr();
  ::generated::zpb::hellomalif::ExceptionErr* mutable_exexceptionerr();
  void set_allocated_exexceptionerr(::generated::zpb::hellomalif::ExceptionErr* exexceptionerr);
 
  // @@protoc_insertion_point(class_scope:generated.zpb.hellomalif.StdCmds_SetLogLevel_Out)
 private:
  void set_has_retval();
  void clear_has_retval();
  void set_has_exexceptionerr();
  void clear_has_exexceptionerr();
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr retval_;
  ::generated::zpb::hellomalif::ExceptionErr* exexceptionerr_;
  friend struct ::protobuf_hellomalif_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class StdCmds_Return : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:generated.zpb.hellomalif.StdCmds_Return) */ {
 public:
  StdCmds_Return();
  virtual ~StdCmds_Return();
 
  StdCmds_Return(const StdCmds_Return& from);
 
  inline StdCmds_Return& operator=(const StdCmds_Return& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  StdCmds_Return(StdCmds_Return&& from) noexcept
    : StdCmds_Return() {
    *this = ::std::move(from);
  }
 
  inline StdCmds_Return& operator=(StdCmds_Return&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const StdCmds_Return& default_instance();
 
  enum ReplyCase {
    kInit = 1,
    kReset = 2,
    kEnable = 3,
    kDisable = 4,
    kGetState = 5,
    kGetStatus = 6,
    kGetVersion = 7,
    kStop = 8,
    kExit = 9,
    kSetLogLevel = 10,
    REPLY_NOT_SET = 0,
  };
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const StdCmds_Return* internal_default_instance() {
    return reinterpret_cast<const StdCmds_Return*>(
               &_StdCmds_Return_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    24;
 
  void Swap(StdCmds_Return* other);
  friend void swap(StdCmds_Return& a, StdCmds_Return& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline StdCmds_Return* New() const final {
    return CreateMaybeMessage<StdCmds_Return>(NULL);
  }
 
  StdCmds_Return* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<StdCmds_Return>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const StdCmds_Return& from);
  void MergeFrom(const StdCmds_Return& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(StdCmds_Return* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // optional .generated.zpb.hellomalif.StdCmds_Init_Out Init = 1;
  bool has_init() const;
  void clear_init();
  static const int kInitFieldNumber = 1;
  private:
  const ::generated::zpb::hellomalif::StdCmds_Init_Out& _internal_init() const;
  public:
  const ::generated::zpb::hellomalif::StdCmds_Init_Out& init() const;
  ::generated::zpb::hellomalif::StdCmds_Init_Out* release_init();
  ::generated::zpb::hellomalif::StdCmds_Init_Out* mutable_init();
  void set_allocated_init(::generated::zpb::hellomalif::StdCmds_Init_Out* init);
 
  // optional .generated.zpb.hellomalif.StdCmds_Reset_Out Reset = 2;
  bool has_reset() const;
  void clear_reset();
  static const int kResetFieldNumber = 2;
  private:
  const ::generated::zpb::hellomalif::StdCmds_Reset_Out& _internal_reset() const;
  public:
  const ::generated::zpb::hellomalif::StdCmds_Reset_Out& reset() const;
  ::generated::zpb::hellomalif::StdCmds_Reset_Out* release_reset();
  ::generated::zpb::hellomalif::StdCmds_Reset_Out* mutable_reset();
  void set_allocated_reset(::generated::zpb::hellomalif::StdCmds_Reset_Out* reset);
 
  // optional .generated.zpb.hellomalif.StdCmds_Enable_Out Enable = 3;
  bool has_enable() const;
  void clear_enable();
  static const int kEnableFieldNumber = 3;
  private:
  const ::generated::zpb::hellomalif::StdCmds_Enable_Out& _internal_enable() const;
  public:
  const ::generated::zpb::hellomalif::StdCmds_Enable_Out& enable() const;
  ::generated::zpb::hellomalif::StdCmds_Enable_Out* release_enable();
  ::generated::zpb::hellomalif::StdCmds_Enable_Out* mutable_enable();
  void set_allocated_enable(::generated::zpb::hellomalif::StdCmds_Enable_Out* enable);
 
  // optional .generated.zpb.hellomalif.StdCmds_Disable_Out Disable = 4;
  bool has_disable() const;
  void clear_disable();
  static const int kDisableFieldNumber = 4;
  private:
  const ::generated::zpb::hellomalif::StdCmds_Disable_Out& _internal_disable() const;
  public:
  const ::generated::zpb::hellomalif::StdCmds_Disable_Out& disable() const;
  ::generated::zpb::hellomalif::StdCmds_Disable_Out* release_disable();
  ::generated::zpb::hellomalif::StdCmds_Disable_Out* mutable_disable();
  void set_allocated_disable(::generated::zpb::hellomalif::StdCmds_Disable_Out* disable);
 
  // optional .generated.zpb.hellomalif.StdCmds_GetState_Out GetState = 5;
  bool has_getstate() const;
  void clear_getstate();
  static const int kGetStateFieldNumber = 5;
  private:
  const ::generated::zpb::hellomalif::StdCmds_GetState_Out& _internal_getstate() const;
  public:
  const ::generated::zpb::hellomalif::StdCmds_GetState_Out& getstate() const;
  ::generated::zpb::hellomalif::StdCmds_GetState_Out* release_getstate();
  ::generated::zpb::hellomalif::StdCmds_GetState_Out* mutable_getstate();
  void set_allocated_getstate(::generated::zpb::hellomalif::StdCmds_GetState_Out* getstate);
 
  // optional .generated.zpb.hellomalif.StdCmds_GetStatus_Out GetStatus = 6;
  bool has_getstatus() const;
  void clear_getstatus();
  static const int kGetStatusFieldNumber = 6;
  private:
  const ::generated::zpb::hellomalif::StdCmds_GetStatus_Out& _internal_getstatus() const;
  public:
  const ::generated::zpb::hellomalif::StdCmds_GetStatus_Out& getstatus() const;
  ::generated::zpb::hellomalif::StdCmds_GetStatus_Out* release_getstatus();
  ::generated::zpb::hellomalif::StdCmds_GetStatus_Out* mutable_getstatus();
  void set_allocated_getstatus(::generated::zpb::hellomalif::StdCmds_GetStatus_Out* getstatus);
 
  // optional .generated.zpb.hellomalif.StdCmds_GetVersion_Out GetVersion = 7;
  bool has_getversion() const;
  void clear_getversion();
  static const int kGetVersionFieldNumber = 7;
  private:
  const ::generated::zpb::hellomalif::StdCmds_GetVersion_Out& _internal_getversion() const;
  public:
  const ::generated::zpb::hellomalif::StdCmds_GetVersion_Out& getversion() const;
  ::generated::zpb::hellomalif::StdCmds_GetVersion_Out* release_getversion();
  ::generated::zpb::hellomalif::StdCmds_GetVersion_Out* mutable_getversion();
  void set_allocated_getversion(::generated::zpb::hellomalif::StdCmds_GetVersion_Out* getversion);
 
  // optional .generated.zpb.hellomalif.StdCmds_Stop_Out Stop = 8;
  bool has_stop() const;
  void clear_stop();
  static const int kStopFieldNumber = 8;
  private:
  const ::generated::zpb::hellomalif::StdCmds_Stop_Out& _internal_stop() const;
  public:
  const ::generated::zpb::hellomalif::StdCmds_Stop_Out& stop() const;
  ::generated::zpb::hellomalif::StdCmds_Stop_Out* release_stop();
  ::generated::zpb::hellomalif::StdCmds_Stop_Out* mutable_stop();
  void set_allocated_stop(::generated::zpb::hellomalif::StdCmds_Stop_Out* stop);
 
  // optional .generated.zpb.hellomalif.StdCmds_Exit_Out Exit = 9;
  bool has_exit() const;
  void clear_exit();
  static const int kExitFieldNumber = 9;
  private:
  const ::generated::zpb::hellomalif::StdCmds_Exit_Out& _internal_exit() const;
  public:
  const ::generated::zpb::hellomalif::StdCmds_Exit_Out& exit() const;
  ::generated::zpb::hellomalif::StdCmds_Exit_Out* release_exit();
  ::generated::zpb::hellomalif::StdCmds_Exit_Out* mutable_exit();
  void set_allocated_exit(::generated::zpb::hellomalif::StdCmds_Exit_Out* exit);
 
  // optional .generated.zpb.hellomalif.StdCmds_SetLogLevel_Out SetLogLevel = 10;
  bool has_setloglevel() const;
  void clear_setloglevel();
  static const int kSetLogLevelFieldNumber = 10;
  private:
  const ::generated::zpb::hellomalif::StdCmds_SetLogLevel_Out& _internal_setloglevel() const;
  public:
  const ::generated::zpb::hellomalif::StdCmds_SetLogLevel_Out& setloglevel() const;
  ::generated::zpb::hellomalif::StdCmds_SetLogLevel_Out* release_setloglevel();
  ::generated::zpb::hellomalif::StdCmds_SetLogLevel_Out* mutable_setloglevel();
  void set_allocated_setloglevel(::generated::zpb::hellomalif::StdCmds_SetLogLevel_Out* setloglevel);
 
  void clear_reply();
  ReplyCase reply_case() const;
  // @@protoc_insertion_point(class_scope:generated.zpb.hellomalif.StdCmds_Return)
 private:
  void set_has_init();
  void set_has_reset();
  void set_has_enable();
  void set_has_disable();
  void set_has_getstate();
  void set_has_getstatus();
  void set_has_getversion();
  void set_has_stop();
  void set_has_exit();
  void set_has_setloglevel();
 
  inline bool has_reply() const;
  inline void clear_has_reply();
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  union ReplyUnion {
    ReplyUnion() {}
    ::generated::zpb::hellomalif::StdCmds_Init_Out* init_;
    ::generated::zpb::hellomalif::StdCmds_Reset_Out* reset_;
    ::generated::zpb::hellomalif::StdCmds_Enable_Out* enable_;
    ::generated::zpb::hellomalif::StdCmds_Disable_Out* disable_;
    ::generated::zpb::hellomalif::StdCmds_GetState_Out* getstate_;
    ::generated::zpb::hellomalif::StdCmds_GetStatus_Out* getstatus_;
    ::generated::zpb::hellomalif::StdCmds_GetVersion_Out* getversion_;
    ::generated::zpb::hellomalif::StdCmds_Stop_Out* stop_;
    ::generated::zpb::hellomalif::StdCmds_Exit_Out* exit_;
    ::generated::zpb::hellomalif::StdCmds_SetLogLevel_Out* setloglevel_;
  } reply_;
  ::google::protobuf::uint32 _oneof_case_[1];
 
  friend struct ::protobuf_hellomalif_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class StdCmds_Reply : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:generated.zpb.hellomalif.StdCmds_Reply) */ {
 public:
  StdCmds_Reply();
  virtual ~StdCmds_Reply();
 
  StdCmds_Reply(const StdCmds_Reply& from);
 
  inline StdCmds_Reply& operator=(const StdCmds_Reply& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  StdCmds_Reply(StdCmds_Reply&& from) noexcept
    : StdCmds_Reply() {
    *this = ::std::move(from);
  }
 
  inline StdCmds_Reply& operator=(StdCmds_Reply&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const StdCmds_Reply& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const StdCmds_Reply* internal_default_instance() {
    return reinterpret_cast<const StdCmds_Reply*>(
               &_StdCmds_Reply_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    25;
 
  void Swap(StdCmds_Reply* other);
  friend void swap(StdCmds_Reply& a, StdCmds_Reply& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline StdCmds_Reply* New() const final {
    return CreateMaybeMessage<StdCmds_Reply>(NULL);
  }
 
  StdCmds_Reply* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<StdCmds_Reply>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const StdCmds_Reply& from);
  void MergeFrom(const StdCmds_Reply& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(StdCmds_Reply* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // required .elt.mal.zpb.rr.ReplyHeader header = 1;
  bool has_header() const;
  void clear_header();
  static const int kHeaderFieldNumber = 1;
  private:
  const ::elt::mal::zpb::rr::ReplyHeader& _internal_header() const;
  public:
  const ::elt::mal::zpb::rr::ReplyHeader& header() const;
  ::elt::mal::zpb::rr::ReplyHeader* release_header();
  ::elt::mal::zpb::rr::ReplyHeader* mutable_header();
  void set_allocated_header(::elt::mal::zpb::rr::ReplyHeader* header);
 
  // optional .generated.zpb.hellomalif.StdCmds_Return data = 2;
  bool has_data() const;
  void clear_data();
  static const int kDataFieldNumber = 2;
  private:
  const ::generated::zpb::hellomalif::StdCmds_Return& _internal_data() const;
  public:
  const ::generated::zpb::hellomalif::StdCmds_Return& data() const;
  ::generated::zpb::hellomalif::StdCmds_Return* release_data();
  ::generated::zpb::hellomalif::StdCmds_Return* mutable_data();
  void set_allocated_data(::generated::zpb::hellomalif::StdCmds_Return* data);
 
  // @@protoc_insertion_point(class_scope:generated.zpb.hellomalif.StdCmds_Reply)
 private:
  void set_has_header();
  void clear_has_header();
  void set_has_data();
  void clear_has_data();
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::elt::mal::zpb::rr::ReplyHeader* header_;
  ::generated::zpb::hellomalif::StdCmds_Return* data_;
  friend struct ::protobuf_hellomalif_2eproto::TableStruct;
};
// ===================================================================
 
 
// ===================================================================
 
#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// ExceptionErr
 
// required string desc = 1;
inline bool ExceptionErr::has_desc() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ExceptionErr::set_has_desc() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ExceptionErr::clear_has_desc() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ExceptionErr::clear_desc() {
  desc_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_desc();
}
inline const ::std::string& ExceptionErr::desc() const {
  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.ExceptionErr.desc)
  return desc_.GetNoArena();
}
inline void ExceptionErr::set_desc(const ::std::string& value) {
  set_has_desc();
  desc_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:generated.zpb.hellomalif.ExceptionErr.desc)
}
#if LANG_CXX11
inline void ExceptionErr::set_desc(::std::string&& value) {
  set_has_desc();
  desc_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:generated.zpb.hellomalif.ExceptionErr.desc)
}
#endif
inline void ExceptionErr::set_desc(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_desc();
  desc_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:generated.zpb.hellomalif.ExceptionErr.desc)
}
inline void ExceptionErr::set_desc(const char* value, size_t size) {
  set_has_desc();
  desc_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:generated.zpb.hellomalif.ExceptionErr.desc)
}
inline ::std::string* ExceptionErr::mutable_desc() {
  set_has_desc();
  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.ExceptionErr.desc)
  return desc_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ExceptionErr::release_desc() {
  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.ExceptionErr.desc)
  if (!has_desc()) {
    return NULL;
  }
  clear_has_desc();
  return desc_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ExceptionErr::set_allocated_desc(::std::string* desc) {
  if (desc != NULL) {
    set_has_desc();
  } else {
    clear_has_desc();
  }
  desc_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), desc);
  // @@protoc_insertion_point(field_set_allocated:generated.zpb.hellomalif.ExceptionErr.desc)
}
 
// -------------------------------------------------------------------
 
// LogInfo
 
// required string level = 1;
inline bool LogInfo::has_level() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void LogInfo::set_has_level() {
  _has_bits_[0] |= 0x00000001u;
}
inline void LogInfo::clear_has_level() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void LogInfo::clear_level() {
  level_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_level();
}
inline const ::std::string& LogInfo::level() const {
  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.LogInfo.level)
  return level_.GetNoArena();
}
inline void LogInfo::set_level(const ::std::string& value) {
  set_has_level();
  level_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:generated.zpb.hellomalif.LogInfo.level)
}
#if LANG_CXX11
inline void LogInfo::set_level(::std::string&& value) {
  set_has_level();
  level_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:generated.zpb.hellomalif.LogInfo.level)
}
#endif
inline void LogInfo::set_level(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_level();
  level_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:generated.zpb.hellomalif.LogInfo.level)
}
inline void LogInfo::set_level(const char* value, size_t size) {
  set_has_level();
  level_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:generated.zpb.hellomalif.LogInfo.level)
}
inline ::std::string* LogInfo::mutable_level() {
  set_has_level();
  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.LogInfo.level)
  return level_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* LogInfo::release_level() {
  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.LogInfo.level)
  if (!has_level()) {
    return NULL;
  }
  clear_has_level();
  return level_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void LogInfo::set_allocated_level(::std::string* level) {
  if (level != NULL) {
    set_has_level();
  } else {
    clear_has_level();
  }
  level_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), level);
  // @@protoc_insertion_point(field_set_allocated:generated.zpb.hellomalif.LogInfo.level)
}
 
// required string logger = 2;
inline bool LogInfo::has_logger() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void LogInfo::set_has_logger() {
  _has_bits_[0] |= 0x00000002u;
}
inline void LogInfo::clear_has_logger() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void LogInfo::clear_logger() {
  logger_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_logger();
}
inline const ::std::string& LogInfo::logger() const {
  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.LogInfo.logger)
  return logger_.GetNoArena();
}
inline void LogInfo::set_logger(const ::std::string& value) {
  set_has_logger();
  logger_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:generated.zpb.hellomalif.LogInfo.logger)
}
#if LANG_CXX11
inline void LogInfo::set_logger(::std::string&& value) {
  set_has_logger();
  logger_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:generated.zpb.hellomalif.LogInfo.logger)
}
#endif
inline void LogInfo::set_logger(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_logger();
  logger_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:generated.zpb.hellomalif.LogInfo.logger)
}
inline void LogInfo::set_logger(const char* value, size_t size) {
  set_has_logger();
  logger_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:generated.zpb.hellomalif.LogInfo.logger)
}
inline ::std::string* LogInfo::mutable_logger() {
  set_has_logger();
  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.LogInfo.logger)
  return logger_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* LogInfo::release_logger() {
  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.LogInfo.logger)
  if (!has_logger()) {
    return NULL;
  }
  clear_has_logger();
  return logger_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void LogInfo::set_allocated_logger(::std::string* logger) {
  if (logger != NULL) {
    set_has_logger();
  } else {
    clear_has_logger();
  }
  logger_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), logger);
  // @@protoc_insertion_point(field_set_allocated:generated.zpb.hellomalif.LogInfo.logger)
}
 
// -------------------------------------------------------------------
 
// StdCmds_Init_In
 
// -------------------------------------------------------------------
 
// StdCmds_Reset_In
 
// -------------------------------------------------------------------
 
// StdCmds_Enable_In
 
// -------------------------------------------------------------------
 
// StdCmds_Disable_In
 
// -------------------------------------------------------------------
 
// StdCmds_GetState_In
 
// -------------------------------------------------------------------
 
// StdCmds_GetStatus_In
 
// -------------------------------------------------------------------
 
// StdCmds_GetVersion_In
 
// -------------------------------------------------------------------
 
// StdCmds_Stop_In
 
// -------------------------------------------------------------------
 
// StdCmds_Exit_In
 
// -------------------------------------------------------------------
 
// StdCmds_SetLogLevel_In
 
// required .generated.zpb.hellomalif.LogInfo info = 1;
inline bool StdCmds_SetLogLevel_In::has_info() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void StdCmds_SetLogLevel_In::set_has_info() {
  _has_bits_[0] |= 0x00000001u;
}
inline void StdCmds_SetLogLevel_In::clear_has_info() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void StdCmds_SetLogLevel_In::clear_info() {
  if (info_ != NULL) info_->Clear();
  clear_has_info();
}
inline const ::generated::zpb::hellomalif::LogInfo& StdCmds_SetLogLevel_In::_internal_info() const {
  return *info_;
}
inline const ::generated::zpb::hellomalif::LogInfo& StdCmds_SetLogLevel_In::info() const {
  const ::generated::zpb::hellomalif::LogInfo* p = info_;
  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_SetLogLevel_In.info)
  return p != NULL ? *p : *reinterpret_cast<const ::generated::zpb::hellomalif::LogInfo*>(
      &::generated::zpb::hellomalif::_LogInfo_default_instance_);
}
inline ::generated::zpb::hellomalif::LogInfo* StdCmds_SetLogLevel_In::release_info() {
  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_SetLogLevel_In.info)
  clear_has_info();
  ::generated::zpb::hellomalif::LogInfo* temp = info_;
  info_ = NULL;
  return temp;
}
inline ::generated::zpb::hellomalif::LogInfo* StdCmds_SetLogLevel_In::mutable_info() {
  set_has_info();
  if (info_ == NULL) {
    auto* p = CreateMaybeMessage<::generated::zpb::hellomalif::LogInfo>(GetArenaNoVirtual());
    info_ = p;
  }
  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_SetLogLevel_In.info)
  return info_;
}
inline void StdCmds_SetLogLevel_In::set_allocated_info(::generated::zpb::hellomalif::LogInfo* info) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete info_;
  }
  if (info) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      info = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, info, submessage_arena);
    }
    set_has_info();
  } else {
    clear_has_info();
  }
  info_ = info;
  // @@protoc_insertion_point(field_set_allocated:generated.zpb.hellomalif.StdCmds_SetLogLevel_In.info)
}
 
// -------------------------------------------------------------------
 
// StdCmds_Call
 
// optional .generated.zpb.hellomalif.StdCmds_Init_In Init = 1;
inline bool StdCmds_Call::has_init() const {
  return request_case() == kInit;
}
inline void StdCmds_Call::set_has_init() {
  _oneof_case_[0] = kInit;
}
inline void StdCmds_Call::clear_init() {
  if (has_init()) {
    delete request_.init_;
    clear_has_request();
  }
}
inline const ::generated::zpb::hellomalif::StdCmds_Init_In& StdCmds_Call::_internal_init() const {
  return *request_.init_;
}
inline ::generated::zpb::hellomalif::StdCmds_Init_In* StdCmds_Call::release_init() {
  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Call.Init)
  if (has_init()) {
    clear_has_request();
      ::generated::zpb::hellomalif::StdCmds_Init_In* temp = request_.init_;
    request_.init_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::generated::zpb::hellomalif::StdCmds_Init_In& StdCmds_Call::init() const {
  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Call.Init)
  return has_init()
      ? *request_.init_
      : *reinterpret_cast< ::generated::zpb::hellomalif::StdCmds_Init_In*>(&::generated::zpb::hellomalif::_StdCmds_Init_In_default_instance_);
}
inline ::generated::zpb::hellomalif::StdCmds_Init_In* StdCmds_Call::mutable_init() {
  if (!has_init()) {
    clear_request();
    set_has_init();
    request_.init_ = CreateMaybeMessage< ::generated::zpb::hellomalif::StdCmds_Init_In >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Call.Init)
  return request_.init_;
}
 
// optional .generated.zpb.hellomalif.StdCmds_Reset_In Reset = 2;
inline bool StdCmds_Call::has_reset() const {
  return request_case() == kReset;
}
inline void StdCmds_Call::set_has_reset() {
  _oneof_case_[0] = kReset;
}
inline void StdCmds_Call::clear_reset() {
  if (has_reset()) {
    delete request_.reset_;
    clear_has_request();
  }
}
inline const ::generated::zpb::hellomalif::StdCmds_Reset_In& StdCmds_Call::_internal_reset() const {
  return *request_.reset_;
}
inline ::generated::zpb::hellomalif::StdCmds_Reset_In* StdCmds_Call::release_reset() {
  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Call.Reset)
  if (has_reset()) {
    clear_has_request();
      ::generated::zpb::hellomalif::StdCmds_Reset_In* temp = request_.reset_;
    request_.reset_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::generated::zpb::hellomalif::StdCmds_Reset_In& StdCmds_Call::reset() const {
  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Call.Reset)
  return has_reset()
      ? *request_.reset_
      : *reinterpret_cast< ::generated::zpb::hellomalif::StdCmds_Reset_In*>(&::generated::zpb::hellomalif::_StdCmds_Reset_In_default_instance_);
}
inline ::generated::zpb::hellomalif::StdCmds_Reset_In* StdCmds_Call::mutable_reset() {
  if (!has_reset()) {
    clear_request();
    set_has_reset();
    request_.reset_ = CreateMaybeMessage< ::generated::zpb::hellomalif::StdCmds_Reset_In >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Call.Reset)
  return request_.reset_;
}
 
// optional .generated.zpb.hellomalif.StdCmds_Enable_In Enable = 3;
inline bool StdCmds_Call::has_enable() const {
  return request_case() == kEnable;
}
inline void StdCmds_Call::set_has_enable() {
  _oneof_case_[0] = kEnable;
}
inline void StdCmds_Call::clear_enable() {
  if (has_enable()) {
    delete request_.enable_;
    clear_has_request();
  }
}
inline const ::generated::zpb::hellomalif::StdCmds_Enable_In& StdCmds_Call::_internal_enable() const {
  return *request_.enable_;
}
inline ::generated::zpb::hellomalif::StdCmds_Enable_In* StdCmds_Call::release_enable() {
  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Call.Enable)
  if (has_enable()) {
    clear_has_request();
      ::generated::zpb::hellomalif::StdCmds_Enable_In* temp = request_.enable_;
    request_.enable_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::generated::zpb::hellomalif::StdCmds_Enable_In& StdCmds_Call::enable() const {
  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Call.Enable)
  return has_enable()
      ? *request_.enable_
      : *reinterpret_cast< ::generated::zpb::hellomalif::StdCmds_Enable_In*>(&::generated::zpb::hellomalif::_StdCmds_Enable_In_default_instance_);
}
inline ::generated::zpb::hellomalif::StdCmds_Enable_In* StdCmds_Call::mutable_enable() {
  if (!has_enable()) {
    clear_request();
    set_has_enable();
    request_.enable_ = CreateMaybeMessage< ::generated::zpb::hellomalif::StdCmds_Enable_In >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Call.Enable)
  return request_.enable_;
}
 
// optional .generated.zpb.hellomalif.StdCmds_Disable_In Disable = 4;
inline bool StdCmds_Call::has_disable() const {
  return request_case() == kDisable;
}
inline void StdCmds_Call::set_has_disable() {
  _oneof_case_[0] = kDisable;
}
inline void StdCmds_Call::clear_disable() {
  if (has_disable()) {
    delete request_.disable_;
    clear_has_request();
  }
}
inline const ::generated::zpb::hellomalif::StdCmds_Disable_In& StdCmds_Call::_internal_disable() const {
  return *request_.disable_;
}
inline ::generated::zpb::hellomalif::StdCmds_Disable_In* StdCmds_Call::release_disable() {
  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Call.Disable)
  if (has_disable()) {
    clear_has_request();
      ::generated::zpb::hellomalif::StdCmds_Disable_In* temp = request_.disable_;
    request_.disable_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::generated::zpb::hellomalif::StdCmds_Disable_In& StdCmds_Call::disable() const {
  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Call.Disable)
  return has_disable()
      ? *request_.disable_
      : *reinterpret_cast< ::generated::zpb::hellomalif::StdCmds_Disable_In*>(&::generated::zpb::hellomalif::_StdCmds_Disable_In_default_instance_);
}
inline ::generated::zpb::hellomalif::StdCmds_Disable_In* StdCmds_Call::mutable_disable() {
  if (!has_disable()) {
    clear_request();
    set_has_disable();
    request_.disable_ = CreateMaybeMessage< ::generated::zpb::hellomalif::StdCmds_Disable_In >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Call.Disable)
  return request_.disable_;
}
 
// optional .generated.zpb.hellomalif.StdCmds_GetState_In GetState = 5;
inline bool StdCmds_Call::has_getstate() const {
  return request_case() == kGetState;
}
inline void StdCmds_Call::set_has_getstate() {
  _oneof_case_[0] = kGetState;
}
inline void StdCmds_Call::clear_getstate() {
  if (has_getstate()) {
    delete request_.getstate_;
    clear_has_request();
  }
}
inline const ::generated::zpb::hellomalif::StdCmds_GetState_In& StdCmds_Call::_internal_getstate() const {
  return *request_.getstate_;
}
inline ::generated::zpb::hellomalif::StdCmds_GetState_In* StdCmds_Call::release_getstate() {
  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Call.GetState)
  if (has_getstate()) {
    clear_has_request();
      ::generated::zpb::hellomalif::StdCmds_GetState_In* temp = request_.getstate_;
    request_.getstate_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::generated::zpb::hellomalif::StdCmds_GetState_In& StdCmds_Call::getstate() const {
  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Call.GetState)
  return has_getstate()
      ? *request_.getstate_
      : *reinterpret_cast< ::generated::zpb::hellomalif::StdCmds_GetState_In*>(&::generated::zpb::hellomalif::_StdCmds_GetState_In_default_instance_);
}
inline ::generated::zpb::hellomalif::StdCmds_GetState_In* StdCmds_Call::mutable_getstate() {
  if (!has_getstate()) {
    clear_request();
    set_has_getstate();
    request_.getstate_ = CreateMaybeMessage< ::generated::zpb::hellomalif::StdCmds_GetState_In >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Call.GetState)
  return request_.getstate_;
}
 
// optional .generated.zpb.hellomalif.StdCmds_GetStatus_In GetStatus = 6;
inline bool StdCmds_Call::has_getstatus() const {
  return request_case() == kGetStatus;
}
inline void StdCmds_Call::set_has_getstatus() {
  _oneof_case_[0] = kGetStatus;
}
inline void StdCmds_Call::clear_getstatus() {
  if (has_getstatus()) {
    delete request_.getstatus_;
    clear_has_request();
  }
}
inline const ::generated::zpb::hellomalif::StdCmds_GetStatus_In& StdCmds_Call::_internal_getstatus() const {
  return *request_.getstatus_;
}
inline ::generated::zpb::hellomalif::StdCmds_GetStatus_In* StdCmds_Call::release_getstatus() {
  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Call.GetStatus)
  if (has_getstatus()) {
    clear_has_request();
      ::generated::zpb::hellomalif::StdCmds_GetStatus_In* temp = request_.getstatus_;
    request_.getstatus_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::generated::zpb::hellomalif::StdCmds_GetStatus_In& StdCmds_Call::getstatus() const {
  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Call.GetStatus)
  return has_getstatus()
      ? *request_.getstatus_
      : *reinterpret_cast< ::generated::zpb::hellomalif::StdCmds_GetStatus_In*>(&::generated::zpb::hellomalif::_StdCmds_GetStatus_In_default_instance_);
}
inline ::generated::zpb::hellomalif::StdCmds_GetStatus_In* StdCmds_Call::mutable_getstatus() {
  if (!has_getstatus()) {
    clear_request();
    set_has_getstatus();
    request_.getstatus_ = CreateMaybeMessage< ::generated::zpb::hellomalif::StdCmds_GetStatus_In >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Call.GetStatus)
  return request_.getstatus_;
}
 
// optional .generated.zpb.hellomalif.StdCmds_GetVersion_In GetVersion = 7;
inline bool StdCmds_Call::has_getversion() const {
  return request_case() == kGetVersion;
}
inline void StdCmds_Call::set_has_getversion() {
  _oneof_case_[0] = kGetVersion;
}
inline void StdCmds_Call::clear_getversion() {
  if (has_getversion()) {
    delete request_.getversion_;
    clear_has_request();
  }
}
inline const ::generated::zpb::hellomalif::StdCmds_GetVersion_In& StdCmds_Call::_internal_getversion() const {
  return *request_.getversion_;
}
inline ::generated::zpb::hellomalif::StdCmds_GetVersion_In* StdCmds_Call::release_getversion() {
  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Call.GetVersion)
  if (has_getversion()) {
    clear_has_request();
      ::generated::zpb::hellomalif::StdCmds_GetVersion_In* temp = request_.getversion_;
    request_.getversion_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::generated::zpb::hellomalif::StdCmds_GetVersion_In& StdCmds_Call::getversion() const {
  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Call.GetVersion)
  return has_getversion()
      ? *request_.getversion_
      : *reinterpret_cast< ::generated::zpb::hellomalif::StdCmds_GetVersion_In*>(&::generated::zpb::hellomalif::_StdCmds_GetVersion_In_default_instance_);
}
inline ::generated::zpb::hellomalif::StdCmds_GetVersion_In* StdCmds_Call::mutable_getversion() {
  if (!has_getversion()) {
    clear_request();
    set_has_getversion();
    request_.getversion_ = CreateMaybeMessage< ::generated::zpb::hellomalif::StdCmds_GetVersion_In >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Call.GetVersion)
  return request_.getversion_;
}
 
// optional .generated.zpb.hellomalif.StdCmds_Stop_In Stop = 8;
inline bool StdCmds_Call::has_stop() const {
  return request_case() == kStop;
}
inline void StdCmds_Call::set_has_stop() {
  _oneof_case_[0] = kStop;
}
inline void StdCmds_Call::clear_stop() {
  if (has_stop()) {
    delete request_.stop_;
    clear_has_request();
  }
}
inline const ::generated::zpb::hellomalif::StdCmds_Stop_In& StdCmds_Call::_internal_stop() const {
  return *request_.stop_;
}
inline ::generated::zpb::hellomalif::StdCmds_Stop_In* StdCmds_Call::release_stop() {
  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Call.Stop)
  if (has_stop()) {
    clear_has_request();
      ::generated::zpb::hellomalif::StdCmds_Stop_In* temp = request_.stop_;
    request_.stop_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::generated::zpb::hellomalif::StdCmds_Stop_In& StdCmds_Call::stop() const {
  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Call.Stop)
  return has_stop()
      ? *request_.stop_
      : *reinterpret_cast< ::generated::zpb::hellomalif::StdCmds_Stop_In*>(&::generated::zpb::hellomalif::_StdCmds_Stop_In_default_instance_);
}
inline ::generated::zpb::hellomalif::StdCmds_Stop_In* StdCmds_Call::mutable_stop() {
  if (!has_stop()) {
    clear_request();
    set_has_stop();
    request_.stop_ = CreateMaybeMessage< ::generated::zpb::hellomalif::StdCmds_Stop_In >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Call.Stop)
  return request_.stop_;
}
 
// optional .generated.zpb.hellomalif.StdCmds_Exit_In Exit = 9;
inline bool StdCmds_Call::has_exit() const {
  return request_case() == kExit;
}
inline void StdCmds_Call::set_has_exit() {
  _oneof_case_[0] = kExit;
}
inline void StdCmds_Call::clear_exit() {
  if (has_exit()) {
    delete request_.exit_;
    clear_has_request();
  }
}
inline const ::generated::zpb::hellomalif::StdCmds_Exit_In& StdCmds_Call::_internal_exit() const {
  return *request_.exit_;
}
inline ::generated::zpb::hellomalif::StdCmds_Exit_In* StdCmds_Call::release_exit() {
  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Call.Exit)
  if (has_exit()) {
    clear_has_request();
      ::generated::zpb::hellomalif::StdCmds_Exit_In* temp = request_.exit_;
    request_.exit_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::generated::zpb::hellomalif::StdCmds_Exit_In& StdCmds_Call::exit() const {
  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Call.Exit)
  return has_exit()
      ? *request_.exit_
      : *reinterpret_cast< ::generated::zpb::hellomalif::StdCmds_Exit_In*>(&::generated::zpb::hellomalif::_StdCmds_Exit_In_default_instance_);
}
inline ::generated::zpb::hellomalif::StdCmds_Exit_In* StdCmds_Call::mutable_exit() {
  if (!has_exit()) {
    clear_request();
    set_has_exit();
    request_.exit_ = CreateMaybeMessage< ::generated::zpb::hellomalif::StdCmds_Exit_In >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Call.Exit)
  return request_.exit_;
}
 
// optional .generated.zpb.hellomalif.StdCmds_SetLogLevel_In SetLogLevel = 10;
inline bool StdCmds_Call::has_setloglevel() const {
  return request_case() == kSetLogLevel;
}
inline void StdCmds_Call::set_has_setloglevel() {
  _oneof_case_[0] = kSetLogLevel;
}
inline void StdCmds_Call::clear_setloglevel() {
  if (has_setloglevel()) {
    delete request_.setloglevel_;
    clear_has_request();
  }
}
inline const ::generated::zpb::hellomalif::StdCmds_SetLogLevel_In& StdCmds_Call::_internal_setloglevel() const {
  return *request_.setloglevel_;
}
inline ::generated::zpb::hellomalif::StdCmds_SetLogLevel_In* StdCmds_Call::release_setloglevel() {
  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Call.SetLogLevel)
  if (has_setloglevel()) {
    clear_has_request();
      ::generated::zpb::hellomalif::StdCmds_SetLogLevel_In* temp = request_.setloglevel_;
    request_.setloglevel_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::generated::zpb::hellomalif::StdCmds_SetLogLevel_In& StdCmds_Call::setloglevel() const {
  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Call.SetLogLevel)
  return has_setloglevel()
      ? *request_.setloglevel_
      : *reinterpret_cast< ::generated::zpb::hellomalif::StdCmds_SetLogLevel_In*>(&::generated::zpb::hellomalif::_StdCmds_SetLogLevel_In_default_instance_);
}
inline ::generated::zpb::hellomalif::StdCmds_SetLogLevel_In* StdCmds_Call::mutable_setloglevel() {
  if (!has_setloglevel()) {
    clear_request();
    set_has_setloglevel();
    request_.setloglevel_ = CreateMaybeMessage< ::generated::zpb::hellomalif::StdCmds_SetLogLevel_In >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Call.SetLogLevel)
  return request_.setloglevel_;
}
 
inline bool StdCmds_Call::has_request() const {
  return request_case() != REQUEST_NOT_SET;
}
inline void StdCmds_Call::clear_has_request() {
  _oneof_case_[0] = REQUEST_NOT_SET;
}
inline StdCmds_Call::RequestCase StdCmds_Call::request_case() const {
  return StdCmds_Call::RequestCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------
 
// StdCmds_Request
 
// required .elt.mal.zpb.rr.RequestHeader header = 1;
inline bool StdCmds_Request::has_header() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void StdCmds_Request::set_has_header() {
  _has_bits_[0] |= 0x00000001u;
}
inline void StdCmds_Request::clear_has_header() {
  _has_bits_[0] &= ~0x00000001u;
}
inline const ::elt::mal::zpb::rr::RequestHeader& StdCmds_Request::_internal_header() const {
  return *header_;
}
inline const ::elt::mal::zpb::rr::RequestHeader& StdCmds_Request::header() const {
  const ::elt::mal::zpb::rr::RequestHeader* p = header_;
  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Request.header)
  return p != NULL ? *p : *reinterpret_cast<const ::elt::mal::zpb::rr::RequestHeader*>(
      &::elt::mal::zpb::rr::_RequestHeader_default_instance_);
}
inline ::elt::mal::zpb::rr::RequestHeader* StdCmds_Request::release_header() {
  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Request.header)
  clear_has_header();
  ::elt::mal::zpb::rr::RequestHeader* temp = header_;
  header_ = NULL;
  return temp;
}
inline ::elt::mal::zpb::rr::RequestHeader* StdCmds_Request::mutable_header() {
  set_has_header();
  if (header_ == NULL) {
    auto* p = CreateMaybeMessage<::elt::mal::zpb::rr::RequestHeader>(GetArenaNoVirtual());
    header_ = p;
  }
  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Request.header)
  return header_;
}
inline void StdCmds_Request::set_allocated_header(::elt::mal::zpb::rr::RequestHeader* header) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete reinterpret_cast< ::google::protobuf::MessageLite*>(header_);
  }
  if (header) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      header = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, header, submessage_arena);
    }
    set_has_header();
  } else {
    clear_has_header();
  }
  header_ = header;
  // @@protoc_insertion_point(field_set_allocated:generated.zpb.hellomalif.StdCmds_Request.header)
}
 
// required .generated.zpb.hellomalif.StdCmds_Call data = 2;
inline bool StdCmds_Request::has_data() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void StdCmds_Request::set_has_data() {
  _has_bits_[0] |= 0x00000002u;
}
inline void StdCmds_Request::clear_has_data() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void StdCmds_Request::clear_data() {
  if (data_ != NULL) data_->Clear();
  clear_has_data();
}
inline const ::generated::zpb::hellomalif::StdCmds_Call& StdCmds_Request::_internal_data() const {
  return *data_;
}
inline const ::generated::zpb::hellomalif::StdCmds_Call& StdCmds_Request::data() const {
  const ::generated::zpb::hellomalif::StdCmds_Call* p = data_;
  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Request.data)
  return p != NULL ? *p : *reinterpret_cast<const ::generated::zpb::hellomalif::StdCmds_Call*>(
      &::generated::zpb::hellomalif::_StdCmds_Call_default_instance_);
}
inline ::generated::zpb::hellomalif::StdCmds_Call* StdCmds_Request::release_data() {
  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Request.data)
  clear_has_data();
  ::generated::zpb::hellomalif::StdCmds_Call* temp = data_;
  data_ = NULL;
  return temp;
}
inline ::generated::zpb::hellomalif::StdCmds_Call* StdCmds_Request::mutable_data() {
  set_has_data();
  if (data_ == NULL) {
    auto* p = CreateMaybeMessage<::generated::zpb::hellomalif::StdCmds_Call>(GetArenaNoVirtual());
    data_ = p;
  }
  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Request.data)
  return data_;
}
inline void StdCmds_Request::set_allocated_data(::generated::zpb::hellomalif::StdCmds_Call* data) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete data_;
  }
  if (data) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      data = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, data, submessage_arena);
    }
    set_has_data();
  } else {
    clear_has_data();
  }
  data_ = data;
  // @@protoc_insertion_point(field_set_allocated:generated.zpb.hellomalif.StdCmds_Request.data)
}
 
// -------------------------------------------------------------------
 
// StdCmds_Init_Out
 
// optional string retval = 1;
inline bool StdCmds_Init_Out::has_retval() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void StdCmds_Init_Out::set_has_retval() {
  _has_bits_[0] |= 0x00000001u;
}
inline void StdCmds_Init_Out::clear_has_retval() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void StdCmds_Init_Out::clear_retval() {
  retval_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_retval();
}
inline const ::std::string& StdCmds_Init_Out::retval() const {
  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Init_Out.retval)
  return retval_.GetNoArena();
}
inline void StdCmds_Init_Out::set_retval(const ::std::string& value) {
  set_has_retval();
  retval_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:generated.zpb.hellomalif.StdCmds_Init_Out.retval)
}
#if LANG_CXX11
inline void StdCmds_Init_Out::set_retval(::std::string&& value) {
  set_has_retval();
  retval_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:generated.zpb.hellomalif.StdCmds_Init_Out.retval)
}
#endif
inline void StdCmds_Init_Out::set_retval(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_retval();
  retval_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:generated.zpb.hellomalif.StdCmds_Init_Out.retval)
}
inline void StdCmds_Init_Out::set_retval(const char* value, size_t size) {
  set_has_retval();
  retval_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:generated.zpb.hellomalif.StdCmds_Init_Out.retval)
}
inline ::std::string* StdCmds_Init_Out::mutable_retval() {
  set_has_retval();
  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Init_Out.retval)
  return retval_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* StdCmds_Init_Out::release_retval() {
  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Init_Out.retval)
  if (!has_retval()) {
    return NULL;
  }
  clear_has_retval();
  return retval_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void StdCmds_Init_Out::set_allocated_retval(::std::string* retval) {
  if (retval != NULL) {
    set_has_retval();
  } else {
    clear_has_retval();
  }
  retval_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), retval);
  // @@protoc_insertion_point(field_set_allocated:generated.zpb.hellomalif.StdCmds_Init_Out.retval)
}
 
// optional .generated.zpb.hellomalif.ExceptionErr exExceptionErr = 2;
inline bool StdCmds_Init_Out::has_exexceptionerr() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void StdCmds_Init_Out::set_has_exexceptionerr() {
  _has_bits_[0] |= 0x00000002u;
}
inline void StdCmds_Init_Out::clear_has_exexceptionerr() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void StdCmds_Init_Out::clear_exexceptionerr() {
  if (exexceptionerr_ != NULL) exexceptionerr_->Clear();
  clear_has_exexceptionerr();
}
inline const ::generated::zpb::hellomalif::ExceptionErr& StdCmds_Init_Out::_internal_exexceptionerr() const {
  return *exexceptionerr_;
}
inline const ::generated::zpb::hellomalif::ExceptionErr& StdCmds_Init_Out::exexceptionerr() const {
  const ::generated::zpb::hellomalif::ExceptionErr* p = exexceptionerr_;
  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Init_Out.exExceptionErr)
  return p != NULL ? *p : *reinterpret_cast<const ::generated::zpb::hellomalif::ExceptionErr*>(
      &::generated::zpb::hellomalif::_ExceptionErr_default_instance_);
}
inline ::generated::zpb::hellomalif::ExceptionErr* StdCmds_Init_Out::release_exexceptionerr() {
  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Init_Out.exExceptionErr)
  clear_has_exexceptionerr();
  ::generated::zpb::hellomalif::ExceptionErr* temp = exexceptionerr_;
  exexceptionerr_ = NULL;
  return temp;
}
inline ::generated::zpb::hellomalif::ExceptionErr* StdCmds_Init_Out::mutable_exexceptionerr() {
  set_has_exexceptionerr();
  if (exexceptionerr_ == NULL) {
    auto* p = CreateMaybeMessage<::generated::zpb::hellomalif::ExceptionErr>(GetArenaNoVirtual());
    exexceptionerr_ = p;
  }
  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Init_Out.exExceptionErr)
  return exexceptionerr_;
}
inline void StdCmds_Init_Out::set_allocated_exexceptionerr(::generated::zpb::hellomalif::ExceptionErr* exexceptionerr) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete exexceptionerr_;
  }
  if (exexceptionerr) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      exexceptionerr = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, exexceptionerr, submessage_arena);
    }
    set_has_exexceptionerr();
  } else {
    clear_has_exexceptionerr();
  }
  exexceptionerr_ = exexceptionerr;
  // @@protoc_insertion_point(field_set_allocated:generated.zpb.hellomalif.StdCmds_Init_Out.exExceptionErr)
}
 
// -------------------------------------------------------------------
 
// StdCmds_Reset_Out
 
// optional string retval = 1;
inline bool StdCmds_Reset_Out::has_retval() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void StdCmds_Reset_Out::set_has_retval() {
  _has_bits_[0] |= 0x00000001u;
}
inline void StdCmds_Reset_Out::clear_has_retval() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void StdCmds_Reset_Out::clear_retval() {
  retval_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_retval();
}
inline const ::std::string& StdCmds_Reset_Out::retval() const {
  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Reset_Out.retval)
  return retval_.GetNoArena();
}
inline void StdCmds_Reset_Out::set_retval(const ::std::string& value) {
  set_has_retval();
  retval_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:generated.zpb.hellomalif.StdCmds_Reset_Out.retval)
}
#if LANG_CXX11
inline void StdCmds_Reset_Out::set_retval(::std::string&& value) {
  set_has_retval();
  retval_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:generated.zpb.hellomalif.StdCmds_Reset_Out.retval)
}
#endif
inline void StdCmds_Reset_Out::set_retval(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_retval();
  retval_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:generated.zpb.hellomalif.StdCmds_Reset_Out.retval)
}
inline void StdCmds_Reset_Out::set_retval(const char* value, size_t size) {
  set_has_retval();
  retval_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:generated.zpb.hellomalif.StdCmds_Reset_Out.retval)
}
inline ::std::string* StdCmds_Reset_Out::mutable_retval() {
  set_has_retval();
  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Reset_Out.retval)
  return retval_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* StdCmds_Reset_Out::release_retval() {
  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Reset_Out.retval)
  if (!has_retval()) {
    return NULL;
  }
  clear_has_retval();
  return retval_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void StdCmds_Reset_Out::set_allocated_retval(::std::string* retval) {
  if (retval != NULL) {
    set_has_retval();
  } else {
    clear_has_retval();
  }
  retval_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), retval);
  // @@protoc_insertion_point(field_set_allocated:generated.zpb.hellomalif.StdCmds_Reset_Out.retval)
}
 
// optional .generated.zpb.hellomalif.ExceptionErr exExceptionErr = 2;
inline bool StdCmds_Reset_Out::has_exexceptionerr() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void StdCmds_Reset_Out::set_has_exexceptionerr() {
  _has_bits_[0] |= 0x00000002u;
}
inline void StdCmds_Reset_Out::clear_has_exexceptionerr() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void StdCmds_Reset_Out::clear_exexceptionerr() {
  if (exexceptionerr_ != NULL) exexceptionerr_->Clear();
  clear_has_exexceptionerr();
}
inline const ::generated::zpb::hellomalif::ExceptionErr& StdCmds_Reset_Out::_internal_exexceptionerr() const {
  return *exexceptionerr_;
}
inline const ::generated::zpb::hellomalif::ExceptionErr& StdCmds_Reset_Out::exexceptionerr() const {
  const ::generated::zpb::hellomalif::ExceptionErr* p = exexceptionerr_;
  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Reset_Out.exExceptionErr)
  return p != NULL ? *p : *reinterpret_cast<const ::generated::zpb::hellomalif::ExceptionErr*>(
      &::generated::zpb::hellomalif::_ExceptionErr_default_instance_);
}
inline ::generated::zpb::hellomalif::ExceptionErr* StdCmds_Reset_Out::release_exexceptionerr() {
  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Reset_Out.exExceptionErr)
  clear_has_exexceptionerr();
  ::generated::zpb::hellomalif::ExceptionErr* temp = exexceptionerr_;
  exexceptionerr_ = NULL;
  return temp;
}
inline ::generated::zpb::hellomalif::ExceptionErr* StdCmds_Reset_Out::mutable_exexceptionerr() {
  set_has_exexceptionerr();
  if (exexceptionerr_ == NULL) {
    auto* p = CreateMaybeMessage<::generated::zpb::hellomalif::ExceptionErr>(GetArenaNoVirtual());
    exexceptionerr_ = p;
  }
  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Reset_Out.exExceptionErr)
  return exexceptionerr_;
}
inline void StdCmds_Reset_Out::set_allocated_exexceptionerr(::generated::zpb::hellomalif::ExceptionErr* exexceptionerr) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete exexceptionerr_;
  }
  if (exexceptionerr) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      exexceptionerr = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, exexceptionerr, submessage_arena);
    }
    set_has_exexceptionerr();
  } else {
    clear_has_exexceptionerr();
  }
  exexceptionerr_ = exexceptionerr;
  // @@protoc_insertion_point(field_set_allocated:generated.zpb.hellomalif.StdCmds_Reset_Out.exExceptionErr)
}
 
// -------------------------------------------------------------------
 
// StdCmds_Enable_Out
 
// optional string retval = 1;
inline bool StdCmds_Enable_Out::has_retval() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void StdCmds_Enable_Out::set_has_retval() {
  _has_bits_[0] |= 0x00000001u;
}
inline void StdCmds_Enable_Out::clear_has_retval() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void StdCmds_Enable_Out::clear_retval() {
  retval_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_retval();
}
inline const ::std::string& StdCmds_Enable_Out::retval() const {
  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Enable_Out.retval)
  return retval_.GetNoArena();
}
inline void StdCmds_Enable_Out::set_retval(const ::std::string& value) {
  set_has_retval();
  retval_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:generated.zpb.hellomalif.StdCmds_Enable_Out.retval)
}
#if LANG_CXX11
inline void StdCmds_Enable_Out::set_retval(::std::string&& value) {
  set_has_retval();
  retval_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:generated.zpb.hellomalif.StdCmds_Enable_Out.retval)
}
#endif
inline void StdCmds_Enable_Out::set_retval(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_retval();
  retval_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:generated.zpb.hellomalif.StdCmds_Enable_Out.retval)
}
inline void StdCmds_Enable_Out::set_retval(const char* value, size_t size) {
  set_has_retval();
  retval_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:generated.zpb.hellomalif.StdCmds_Enable_Out.retval)
}
inline ::std::string* StdCmds_Enable_Out::mutable_retval() {
  set_has_retval();
  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Enable_Out.retval)
  return retval_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* StdCmds_Enable_Out::release_retval() {
  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Enable_Out.retval)
  if (!has_retval()) {
    return NULL;
  }
  clear_has_retval();
  return retval_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void StdCmds_Enable_Out::set_allocated_retval(::std::string* retval) {
  if (retval != NULL) {
    set_has_retval();
  } else {
    clear_has_retval();
  }
  retval_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), retval);
  // @@protoc_insertion_point(field_set_allocated:generated.zpb.hellomalif.StdCmds_Enable_Out.retval)
}
 
// optional .generated.zpb.hellomalif.ExceptionErr exExceptionErr = 2;
inline bool StdCmds_Enable_Out::has_exexceptionerr() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void StdCmds_Enable_Out::set_has_exexceptionerr() {
  _has_bits_[0] |= 0x00000002u;
}
inline void StdCmds_Enable_Out::clear_has_exexceptionerr() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void StdCmds_Enable_Out::clear_exexceptionerr() {
  if (exexceptionerr_ != NULL) exexceptionerr_->Clear();
  clear_has_exexceptionerr();
}
inline const ::generated::zpb::hellomalif::ExceptionErr& StdCmds_Enable_Out::_internal_exexceptionerr() const {
  return *exexceptionerr_;
}
inline const ::generated::zpb::hellomalif::ExceptionErr& StdCmds_Enable_Out::exexceptionerr() const {
  const ::generated::zpb::hellomalif::ExceptionErr* p = exexceptionerr_;
  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Enable_Out.exExceptionErr)
  return p != NULL ? *p : *reinterpret_cast<const ::generated::zpb::hellomalif::ExceptionErr*>(
      &::generated::zpb::hellomalif::_ExceptionErr_default_instance_);
}
inline ::generated::zpb::hellomalif::ExceptionErr* StdCmds_Enable_Out::release_exexceptionerr() {
  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Enable_Out.exExceptionErr)
  clear_has_exexceptionerr();
  ::generated::zpb::hellomalif::ExceptionErr* temp = exexceptionerr_;
  exexceptionerr_ = NULL;
  return temp;
}
inline ::generated::zpb::hellomalif::ExceptionErr* StdCmds_Enable_Out::mutable_exexceptionerr() {
  set_has_exexceptionerr();
  if (exexceptionerr_ == NULL) {
    auto* p = CreateMaybeMessage<::generated::zpb::hellomalif::ExceptionErr>(GetArenaNoVirtual());
    exexceptionerr_ = p;
  }
  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Enable_Out.exExceptionErr)
  return exexceptionerr_;
}
inline void StdCmds_Enable_Out::set_allocated_exexceptionerr(::generated::zpb::hellomalif::ExceptionErr* exexceptionerr) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete exexceptionerr_;
  }
  if (exexceptionerr) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      exexceptionerr = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, exexceptionerr, submessage_arena);
    }
    set_has_exexceptionerr();
  } else {
    clear_has_exexceptionerr();
  }
  exexceptionerr_ = exexceptionerr;
  // @@protoc_insertion_point(field_set_allocated:generated.zpb.hellomalif.StdCmds_Enable_Out.exExceptionErr)
}
 
// -------------------------------------------------------------------
 
// StdCmds_Disable_Out
 
// optional string retval = 1;
inline bool StdCmds_Disable_Out::has_retval() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void StdCmds_Disable_Out::set_has_retval() {
  _has_bits_[0] |= 0x00000001u;
}
inline void StdCmds_Disable_Out::clear_has_retval() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void StdCmds_Disable_Out::clear_retval() {
  retval_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_retval();
}
inline const ::std::string& StdCmds_Disable_Out::retval() const {
  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Disable_Out.retval)
  return retval_.GetNoArena();
}
inline void StdCmds_Disable_Out::set_retval(const ::std::string& value) {
  set_has_retval();
  retval_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:generated.zpb.hellomalif.StdCmds_Disable_Out.retval)
}
#if LANG_CXX11
inline void StdCmds_Disable_Out::set_retval(::std::string&& value) {
  set_has_retval();
  retval_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:generated.zpb.hellomalif.StdCmds_Disable_Out.retval)
}
#endif
inline void StdCmds_Disable_Out::set_retval(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_retval();
  retval_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:generated.zpb.hellomalif.StdCmds_Disable_Out.retval)
}
inline void StdCmds_Disable_Out::set_retval(const char* value, size_t size) {
  set_has_retval();
  retval_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:generated.zpb.hellomalif.StdCmds_Disable_Out.retval)
}
inline ::std::string* StdCmds_Disable_Out::mutable_retval() {
  set_has_retval();
  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Disable_Out.retval)
  return retval_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* StdCmds_Disable_Out::release_retval() {
  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Disable_Out.retval)
  if (!has_retval()) {
    return NULL;
  }
  clear_has_retval();
  return retval_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void StdCmds_Disable_Out::set_allocated_retval(::std::string* retval) {
  if (retval != NULL) {
    set_has_retval();
  } else {
    clear_has_retval();
  }
  retval_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), retval);
  // @@protoc_insertion_point(field_set_allocated:generated.zpb.hellomalif.StdCmds_Disable_Out.retval)
}
 
// optional .generated.zpb.hellomalif.ExceptionErr exExceptionErr = 2;
inline bool StdCmds_Disable_Out::has_exexceptionerr() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void StdCmds_Disable_Out::set_has_exexceptionerr() {
  _has_bits_[0] |= 0x00000002u;
}
inline void StdCmds_Disable_Out::clear_has_exexceptionerr() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void StdCmds_Disable_Out::clear_exexceptionerr() {
  if (exexceptionerr_ != NULL) exexceptionerr_->Clear();
  clear_has_exexceptionerr();
}
inline const ::generated::zpb::hellomalif::ExceptionErr& StdCmds_Disable_Out::_internal_exexceptionerr() const {
  return *exexceptionerr_;
}
inline const ::generated::zpb::hellomalif::ExceptionErr& StdCmds_Disable_Out::exexceptionerr() const {
  const ::generated::zpb::hellomalif::ExceptionErr* p = exexceptionerr_;
  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Disable_Out.exExceptionErr)
  return p != NULL ? *p : *reinterpret_cast<const ::generated::zpb::hellomalif::ExceptionErr*>(
      &::generated::zpb::hellomalif::_ExceptionErr_default_instance_);
}
inline ::generated::zpb::hellomalif::ExceptionErr* StdCmds_Disable_Out::release_exexceptionerr() {
  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Disable_Out.exExceptionErr)
  clear_has_exexceptionerr();
  ::generated::zpb::hellomalif::ExceptionErr* temp = exexceptionerr_;
  exexceptionerr_ = NULL;
  return temp;
}
inline ::generated::zpb::hellomalif::ExceptionErr* StdCmds_Disable_Out::mutable_exexceptionerr() {
  set_has_exexceptionerr();
  if (exexceptionerr_ == NULL) {
    auto* p = CreateMaybeMessage<::generated::zpb::hellomalif::ExceptionErr>(GetArenaNoVirtual());
    exexceptionerr_ = p;
  }
  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Disable_Out.exExceptionErr)
  return exexceptionerr_;
}
inline void StdCmds_Disable_Out::set_allocated_exexceptionerr(::generated::zpb::hellomalif::ExceptionErr* exexceptionerr) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete exexceptionerr_;
  }
  if (exexceptionerr) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      exexceptionerr = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, exexceptionerr, submessage_arena);
    }
    set_has_exexceptionerr();
  } else {
    clear_has_exexceptionerr();
  }
  exexceptionerr_ = exexceptionerr;
  // @@protoc_insertion_point(field_set_allocated:generated.zpb.hellomalif.StdCmds_Disable_Out.exExceptionErr)
}
 
// -------------------------------------------------------------------
 
// StdCmds_GetState_Out
 
// optional string retval = 1;
inline bool StdCmds_GetState_Out::has_retval() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void StdCmds_GetState_Out::set_has_retval() {
  _has_bits_[0] |= 0x00000001u;
}
inline void StdCmds_GetState_Out::clear_has_retval() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void StdCmds_GetState_Out::clear_retval() {
  retval_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_retval();
}
inline const ::std::string& StdCmds_GetState_Out::retval() const {
  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_GetState_Out.retval)
  return retval_.GetNoArena();
}
inline void StdCmds_GetState_Out::set_retval(const ::std::string& value) {
  set_has_retval();
  retval_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:generated.zpb.hellomalif.StdCmds_GetState_Out.retval)
}
#if LANG_CXX11
inline void StdCmds_GetState_Out::set_retval(::std::string&& value) {
  set_has_retval();
  retval_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:generated.zpb.hellomalif.StdCmds_GetState_Out.retval)
}
#endif
inline void StdCmds_GetState_Out::set_retval(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_retval();
  retval_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:generated.zpb.hellomalif.StdCmds_GetState_Out.retval)
}
inline void StdCmds_GetState_Out::set_retval(const char* value, size_t size) {
  set_has_retval();
  retval_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:generated.zpb.hellomalif.StdCmds_GetState_Out.retval)
}
inline ::std::string* StdCmds_GetState_Out::mutable_retval() {
  set_has_retval();
  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_GetState_Out.retval)
  return retval_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* StdCmds_GetState_Out::release_retval() {
  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_GetState_Out.retval)
  if (!has_retval()) {
    return NULL;
  }
  clear_has_retval();
  return retval_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void StdCmds_GetState_Out::set_allocated_retval(::std::string* retval) {
  if (retval != NULL) {
    set_has_retval();
  } else {
    clear_has_retval();
  }
  retval_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), retval);
  // @@protoc_insertion_point(field_set_allocated:generated.zpb.hellomalif.StdCmds_GetState_Out.retval)
}
 
// optional .generated.zpb.hellomalif.ExceptionErr exExceptionErr = 2;
inline bool StdCmds_GetState_Out::has_exexceptionerr() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void StdCmds_GetState_Out::set_has_exexceptionerr() {
  _has_bits_[0] |= 0x00000002u;
}
inline void StdCmds_GetState_Out::clear_has_exexceptionerr() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void StdCmds_GetState_Out::clear_exexceptionerr() {
  if (exexceptionerr_ != NULL) exexceptionerr_->Clear();
  clear_has_exexceptionerr();
}
inline const ::generated::zpb::hellomalif::ExceptionErr& StdCmds_GetState_Out::_internal_exexceptionerr() const {
  return *exexceptionerr_;
}
inline const ::generated::zpb::hellomalif::ExceptionErr& StdCmds_GetState_Out::exexceptionerr() const {
  const ::generated::zpb::hellomalif::ExceptionErr* p = exexceptionerr_;
  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_GetState_Out.exExceptionErr)
  return p != NULL ? *p : *reinterpret_cast<const ::generated::zpb::hellomalif::ExceptionErr*>(
      &::generated::zpb::hellomalif::_ExceptionErr_default_instance_);
}
inline ::generated::zpb::hellomalif::ExceptionErr* StdCmds_GetState_Out::release_exexceptionerr() {
  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_GetState_Out.exExceptionErr)
  clear_has_exexceptionerr();
  ::generated::zpb::hellomalif::ExceptionErr* temp = exexceptionerr_;
  exexceptionerr_ = NULL;
  return temp;
}
inline ::generated::zpb::hellomalif::ExceptionErr* StdCmds_GetState_Out::mutable_exexceptionerr() {
  set_has_exexceptionerr();
  if (exexceptionerr_ == NULL) {
    auto* p = CreateMaybeMessage<::generated::zpb::hellomalif::ExceptionErr>(GetArenaNoVirtual());
    exexceptionerr_ = p;
  }
  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_GetState_Out.exExceptionErr)
  return exexceptionerr_;
}
inline void StdCmds_GetState_Out::set_allocated_exexceptionerr(::generated::zpb::hellomalif::ExceptionErr* exexceptionerr) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete exexceptionerr_;
  }
  if (exexceptionerr) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      exexceptionerr = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, exexceptionerr, submessage_arena);
    }
    set_has_exexceptionerr();
  } else {
    clear_has_exexceptionerr();
  }
  exexceptionerr_ = exexceptionerr;
  // @@protoc_insertion_point(field_set_allocated:generated.zpb.hellomalif.StdCmds_GetState_Out.exExceptionErr)
}
 
// -------------------------------------------------------------------
 
// StdCmds_GetStatus_Out
 
// optional string retval = 1;
inline bool StdCmds_GetStatus_Out::has_retval() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void StdCmds_GetStatus_Out::set_has_retval() {
  _has_bits_[0] |= 0x00000001u;
}
inline void StdCmds_GetStatus_Out::clear_has_retval() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void StdCmds_GetStatus_Out::clear_retval() {
  retval_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_retval();
}
inline const ::std::string& StdCmds_GetStatus_Out::retval() const {
  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_GetStatus_Out.retval)
  return retval_.GetNoArena();
}
inline void StdCmds_GetStatus_Out::set_retval(const ::std::string& value) {
  set_has_retval();
  retval_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:generated.zpb.hellomalif.StdCmds_GetStatus_Out.retval)
}
#if LANG_CXX11
inline void StdCmds_GetStatus_Out::set_retval(::std::string&& value) {
  set_has_retval();
  retval_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:generated.zpb.hellomalif.StdCmds_GetStatus_Out.retval)
}
#endif
inline void StdCmds_GetStatus_Out::set_retval(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_retval();
  retval_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:generated.zpb.hellomalif.StdCmds_GetStatus_Out.retval)
}
inline void StdCmds_GetStatus_Out::set_retval(const char* value, size_t size) {
  set_has_retval();
  retval_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:generated.zpb.hellomalif.StdCmds_GetStatus_Out.retval)
}
inline ::std::string* StdCmds_GetStatus_Out::mutable_retval() {
  set_has_retval();
  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_GetStatus_Out.retval)
  return retval_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* StdCmds_GetStatus_Out::release_retval() {
  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_GetStatus_Out.retval)
  if (!has_retval()) {
    return NULL;
  }
  clear_has_retval();
  return retval_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void StdCmds_GetStatus_Out::set_allocated_retval(::std::string* retval) {
  if (retval != NULL) {
    set_has_retval();
  } else {
    clear_has_retval();
  }
  retval_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), retval);
  // @@protoc_insertion_point(field_set_allocated:generated.zpb.hellomalif.StdCmds_GetStatus_Out.retval)
}
 
// optional .generated.zpb.hellomalif.ExceptionErr exExceptionErr = 2;
inline bool StdCmds_GetStatus_Out::has_exexceptionerr() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void StdCmds_GetStatus_Out::set_has_exexceptionerr() {
  _has_bits_[0] |= 0x00000002u;
}
inline void StdCmds_GetStatus_Out::clear_has_exexceptionerr() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void StdCmds_GetStatus_Out::clear_exexceptionerr() {
  if (exexceptionerr_ != NULL) exexceptionerr_->Clear();
  clear_has_exexceptionerr();
}
inline const ::generated::zpb::hellomalif::ExceptionErr& StdCmds_GetStatus_Out::_internal_exexceptionerr() const {
  return *exexceptionerr_;
}
inline const ::generated::zpb::hellomalif::ExceptionErr& StdCmds_GetStatus_Out::exexceptionerr() const {
  const ::generated::zpb::hellomalif::ExceptionErr* p = exexceptionerr_;
  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_GetStatus_Out.exExceptionErr)
  return p != NULL ? *p : *reinterpret_cast<const ::generated::zpb::hellomalif::ExceptionErr*>(
      &::generated::zpb::hellomalif::_ExceptionErr_default_instance_);
}
inline ::generated::zpb::hellomalif::ExceptionErr* StdCmds_GetStatus_Out::release_exexceptionerr() {
  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_GetStatus_Out.exExceptionErr)
  clear_has_exexceptionerr();
  ::generated::zpb::hellomalif::ExceptionErr* temp = exexceptionerr_;
  exexceptionerr_ = NULL;
  return temp;
}
inline ::generated::zpb::hellomalif::ExceptionErr* StdCmds_GetStatus_Out::mutable_exexceptionerr() {
  set_has_exexceptionerr();
  if (exexceptionerr_ == NULL) {
    auto* p = CreateMaybeMessage<::generated::zpb::hellomalif::ExceptionErr>(GetArenaNoVirtual());
    exexceptionerr_ = p;
  }
  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_GetStatus_Out.exExceptionErr)
  return exexceptionerr_;
}
inline void StdCmds_GetStatus_Out::set_allocated_exexceptionerr(::generated::zpb::hellomalif::ExceptionErr* exexceptionerr) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete exexceptionerr_;
  }
  if (exexceptionerr) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      exexceptionerr = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, exexceptionerr, submessage_arena);
    }
    set_has_exexceptionerr();
  } else {
    clear_has_exexceptionerr();
  }
  exexceptionerr_ = exexceptionerr;
  // @@protoc_insertion_point(field_set_allocated:generated.zpb.hellomalif.StdCmds_GetStatus_Out.exExceptionErr)
}
 
// -------------------------------------------------------------------
 
// StdCmds_GetVersion_Out
 
// optional string retval = 1;
inline bool StdCmds_GetVersion_Out::has_retval() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void StdCmds_GetVersion_Out::set_has_retval() {
  _has_bits_[0] |= 0x00000001u;
}
inline void StdCmds_GetVersion_Out::clear_has_retval() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void StdCmds_GetVersion_Out::clear_retval() {
  retval_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_retval();
}
inline const ::std::string& StdCmds_GetVersion_Out::retval() const {
  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_GetVersion_Out.retval)
  return retval_.GetNoArena();
}
inline void StdCmds_GetVersion_Out::set_retval(const ::std::string& value) {
  set_has_retval();
  retval_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:generated.zpb.hellomalif.StdCmds_GetVersion_Out.retval)
}
#if LANG_CXX11
inline void StdCmds_GetVersion_Out::set_retval(::std::string&& value) {
  set_has_retval();
  retval_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:generated.zpb.hellomalif.StdCmds_GetVersion_Out.retval)
}
#endif
inline void StdCmds_GetVersion_Out::set_retval(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_retval();
  retval_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:generated.zpb.hellomalif.StdCmds_GetVersion_Out.retval)
}
inline void StdCmds_GetVersion_Out::set_retval(const char* value, size_t size) {
  set_has_retval();
  retval_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:generated.zpb.hellomalif.StdCmds_GetVersion_Out.retval)
}
inline ::std::string* StdCmds_GetVersion_Out::mutable_retval() {
  set_has_retval();
  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_GetVersion_Out.retval)
  return retval_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* StdCmds_GetVersion_Out::release_retval() {
  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_GetVersion_Out.retval)
  if (!has_retval()) {
    return NULL;
  }
  clear_has_retval();
  return retval_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void StdCmds_GetVersion_Out::set_allocated_retval(::std::string* retval) {
  if (retval != NULL) {
    set_has_retval();
  } else {
    clear_has_retval();
  }
  retval_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), retval);
  // @@protoc_insertion_point(field_set_allocated:generated.zpb.hellomalif.StdCmds_GetVersion_Out.retval)
}
 
// optional .generated.zpb.hellomalif.ExceptionErr exExceptionErr = 2;
inline bool StdCmds_GetVersion_Out::has_exexceptionerr() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void StdCmds_GetVersion_Out::set_has_exexceptionerr() {
  _has_bits_[0] |= 0x00000002u;
}
inline void StdCmds_GetVersion_Out::clear_has_exexceptionerr() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void StdCmds_GetVersion_Out::clear_exexceptionerr() {
  if (exexceptionerr_ != NULL) exexceptionerr_->Clear();
  clear_has_exexceptionerr();
}
inline const ::generated::zpb::hellomalif::ExceptionErr& StdCmds_GetVersion_Out::_internal_exexceptionerr() const {
  return *exexceptionerr_;
}
inline const ::generated::zpb::hellomalif::ExceptionErr& StdCmds_GetVersion_Out::exexceptionerr() const {
  const ::generated::zpb::hellomalif::ExceptionErr* p = exexceptionerr_;
  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_GetVersion_Out.exExceptionErr)
  return p != NULL ? *p : *reinterpret_cast<const ::generated::zpb::hellomalif::ExceptionErr*>(
      &::generated::zpb::hellomalif::_ExceptionErr_default_instance_);
}
inline ::generated::zpb::hellomalif::ExceptionErr* StdCmds_GetVersion_Out::release_exexceptionerr() {
  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_GetVersion_Out.exExceptionErr)
  clear_has_exexceptionerr();
  ::generated::zpb::hellomalif::ExceptionErr* temp = exexceptionerr_;
  exexceptionerr_ = NULL;
  return temp;
}
inline ::generated::zpb::hellomalif::ExceptionErr* StdCmds_GetVersion_Out::mutable_exexceptionerr() {
  set_has_exexceptionerr();
  if (exexceptionerr_ == NULL) {
    auto* p = CreateMaybeMessage<::generated::zpb::hellomalif::ExceptionErr>(GetArenaNoVirtual());
    exexceptionerr_ = p;
  }
  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_GetVersion_Out.exExceptionErr)
  return exexceptionerr_;
}
inline void StdCmds_GetVersion_Out::set_allocated_exexceptionerr(::generated::zpb::hellomalif::ExceptionErr* exexceptionerr) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete exexceptionerr_;
  }
  if (exexceptionerr) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      exexceptionerr = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, exexceptionerr, submessage_arena);
    }
    set_has_exexceptionerr();
  } else {
    clear_has_exexceptionerr();
  }
  exexceptionerr_ = exexceptionerr;
  // @@protoc_insertion_point(field_set_allocated:generated.zpb.hellomalif.StdCmds_GetVersion_Out.exExceptionErr)
}
 
// -------------------------------------------------------------------
 
// StdCmds_Stop_Out
 
// optional string retval = 1;
inline bool StdCmds_Stop_Out::has_retval() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void StdCmds_Stop_Out::set_has_retval() {
  _has_bits_[0] |= 0x00000001u;
}
inline void StdCmds_Stop_Out::clear_has_retval() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void StdCmds_Stop_Out::clear_retval() {
  retval_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_retval();
}
inline const ::std::string& StdCmds_Stop_Out::retval() const {
  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Stop_Out.retval)
  return retval_.GetNoArena();
}
inline void StdCmds_Stop_Out::set_retval(const ::std::string& value) {
  set_has_retval();
  retval_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:generated.zpb.hellomalif.StdCmds_Stop_Out.retval)
}
#if LANG_CXX11
inline void StdCmds_Stop_Out::set_retval(::std::string&& value) {
  set_has_retval();
  retval_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:generated.zpb.hellomalif.StdCmds_Stop_Out.retval)
}
#endif
inline void StdCmds_Stop_Out::set_retval(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_retval();
  retval_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:generated.zpb.hellomalif.StdCmds_Stop_Out.retval)
}
inline void StdCmds_Stop_Out::set_retval(const char* value, size_t size) {
  set_has_retval();
  retval_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:generated.zpb.hellomalif.StdCmds_Stop_Out.retval)
}
inline ::std::string* StdCmds_Stop_Out::mutable_retval() {
  set_has_retval();
  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Stop_Out.retval)
  return retval_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* StdCmds_Stop_Out::release_retval() {
  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Stop_Out.retval)
  if (!has_retval()) {
    return NULL;
  }
  clear_has_retval();
  return retval_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void StdCmds_Stop_Out::set_allocated_retval(::std::string* retval) {
  if (retval != NULL) {
    set_has_retval();
  } else {
    clear_has_retval();
  }
  retval_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), retval);
  // @@protoc_insertion_point(field_set_allocated:generated.zpb.hellomalif.StdCmds_Stop_Out.retval)
}
 
// optional .generated.zpb.hellomalif.ExceptionErr exExceptionErr = 2;
inline bool StdCmds_Stop_Out::has_exexceptionerr() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void StdCmds_Stop_Out::set_has_exexceptionerr() {
  _has_bits_[0] |= 0x00000002u;
}
inline void StdCmds_Stop_Out::clear_has_exexceptionerr() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void StdCmds_Stop_Out::clear_exexceptionerr() {
  if (exexceptionerr_ != NULL) exexceptionerr_->Clear();
  clear_has_exexceptionerr();
}
inline const ::generated::zpb::hellomalif::ExceptionErr& StdCmds_Stop_Out::_internal_exexceptionerr() const {
  return *exexceptionerr_;
}
inline const ::generated::zpb::hellomalif::ExceptionErr& StdCmds_Stop_Out::exexceptionerr() const {
  const ::generated::zpb::hellomalif::ExceptionErr* p = exexceptionerr_;
  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Stop_Out.exExceptionErr)
  return p != NULL ? *p : *reinterpret_cast<const ::generated::zpb::hellomalif::ExceptionErr*>(
      &::generated::zpb::hellomalif::_ExceptionErr_default_instance_);
}
inline ::generated::zpb::hellomalif::ExceptionErr* StdCmds_Stop_Out::release_exexceptionerr() {
  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Stop_Out.exExceptionErr)
  clear_has_exexceptionerr();
  ::generated::zpb::hellomalif::ExceptionErr* temp = exexceptionerr_;
  exexceptionerr_ = NULL;
  return temp;
}
inline ::generated::zpb::hellomalif::ExceptionErr* StdCmds_Stop_Out::mutable_exexceptionerr() {
  set_has_exexceptionerr();
  if (exexceptionerr_ == NULL) {
    auto* p = CreateMaybeMessage<::generated::zpb::hellomalif::ExceptionErr>(GetArenaNoVirtual());
    exexceptionerr_ = p;
  }
  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Stop_Out.exExceptionErr)
  return exexceptionerr_;
}
inline void StdCmds_Stop_Out::set_allocated_exexceptionerr(::generated::zpb::hellomalif::ExceptionErr* exexceptionerr) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete exexceptionerr_;
  }
  if (exexceptionerr) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      exexceptionerr = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, exexceptionerr, submessage_arena);
    }
    set_has_exexceptionerr();
  } else {
    clear_has_exexceptionerr();
  }
  exexceptionerr_ = exexceptionerr;
  // @@protoc_insertion_point(field_set_allocated:generated.zpb.hellomalif.StdCmds_Stop_Out.exExceptionErr)
}
 
// -------------------------------------------------------------------
 
// StdCmds_Exit_Out
 
// optional string retval = 1;
inline bool StdCmds_Exit_Out::has_retval() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void StdCmds_Exit_Out::set_has_retval() {
  _has_bits_[0] |= 0x00000001u;
}
inline void StdCmds_Exit_Out::clear_has_retval() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void StdCmds_Exit_Out::clear_retval() {
  retval_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_retval();
}
inline const ::std::string& StdCmds_Exit_Out::retval() const {
  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Exit_Out.retval)
  return retval_.GetNoArena();
}
inline void StdCmds_Exit_Out::set_retval(const ::std::string& value) {
  set_has_retval();
  retval_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:generated.zpb.hellomalif.StdCmds_Exit_Out.retval)
}
#if LANG_CXX11
inline void StdCmds_Exit_Out::set_retval(::std::string&& value) {
  set_has_retval();
  retval_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:generated.zpb.hellomalif.StdCmds_Exit_Out.retval)
}
#endif
inline void StdCmds_Exit_Out::set_retval(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_retval();
  retval_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:generated.zpb.hellomalif.StdCmds_Exit_Out.retval)
}
inline void StdCmds_Exit_Out::set_retval(const char* value, size_t size) {
  set_has_retval();
  retval_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:generated.zpb.hellomalif.StdCmds_Exit_Out.retval)
}
inline ::std::string* StdCmds_Exit_Out::mutable_retval() {
  set_has_retval();
  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Exit_Out.retval)
  return retval_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* StdCmds_Exit_Out::release_retval() {
  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Exit_Out.retval)
  if (!has_retval()) {
    return NULL;
  }
  clear_has_retval();
  return retval_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void StdCmds_Exit_Out::set_allocated_retval(::std::string* retval) {
  if (retval != NULL) {
    set_has_retval();
  } else {
    clear_has_retval();
  }
  retval_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), retval);
  // @@protoc_insertion_point(field_set_allocated:generated.zpb.hellomalif.StdCmds_Exit_Out.retval)
}
 
// optional .generated.zpb.hellomalif.ExceptionErr exExceptionErr = 2;
inline bool StdCmds_Exit_Out::has_exexceptionerr() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void StdCmds_Exit_Out::set_has_exexceptionerr() {
  _has_bits_[0] |= 0x00000002u;
}
inline void StdCmds_Exit_Out::clear_has_exexceptionerr() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void StdCmds_Exit_Out::clear_exexceptionerr() {
  if (exexceptionerr_ != NULL) exexceptionerr_->Clear();
  clear_has_exexceptionerr();
}
inline const ::generated::zpb::hellomalif::ExceptionErr& StdCmds_Exit_Out::_internal_exexceptionerr() const {
  return *exexceptionerr_;
}
inline const ::generated::zpb::hellomalif::ExceptionErr& StdCmds_Exit_Out::exexceptionerr() const {
  const ::generated::zpb::hellomalif::ExceptionErr* p = exexceptionerr_;
  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Exit_Out.exExceptionErr)
  return p != NULL ? *p : *reinterpret_cast<const ::generated::zpb::hellomalif::ExceptionErr*>(
      &::generated::zpb::hellomalif::_ExceptionErr_default_instance_);
}
inline ::generated::zpb::hellomalif::ExceptionErr* StdCmds_Exit_Out::release_exexceptionerr() {
  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Exit_Out.exExceptionErr)
  clear_has_exexceptionerr();
  ::generated::zpb::hellomalif::ExceptionErr* temp = exexceptionerr_;
  exexceptionerr_ = NULL;
  return temp;
}
inline ::generated::zpb::hellomalif::ExceptionErr* StdCmds_Exit_Out::mutable_exexceptionerr() {
  set_has_exexceptionerr();
  if (exexceptionerr_ == NULL) {
    auto* p = CreateMaybeMessage<::generated::zpb::hellomalif::ExceptionErr>(GetArenaNoVirtual());
    exexceptionerr_ = p;
  }
  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Exit_Out.exExceptionErr)
  return exexceptionerr_;
}
inline void StdCmds_Exit_Out::set_allocated_exexceptionerr(::generated::zpb::hellomalif::ExceptionErr* exexceptionerr) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete exexceptionerr_;
  }
  if (exexceptionerr) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      exexceptionerr = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, exexceptionerr, submessage_arena);
    }
    set_has_exexceptionerr();
  } else {
    clear_has_exexceptionerr();
  }
  exexceptionerr_ = exexceptionerr;
  // @@protoc_insertion_point(field_set_allocated:generated.zpb.hellomalif.StdCmds_Exit_Out.exExceptionErr)
}
 
// -------------------------------------------------------------------
 
// StdCmds_SetLogLevel_Out
 
// optional string retval = 1;
inline bool StdCmds_SetLogLevel_Out::has_retval() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void StdCmds_SetLogLevel_Out::set_has_retval() {
  _has_bits_[0] |= 0x00000001u;
}
inline void StdCmds_SetLogLevel_Out::clear_has_retval() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void StdCmds_SetLogLevel_Out::clear_retval() {
  retval_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_retval();
}
inline const ::std::string& StdCmds_SetLogLevel_Out::retval() const {
  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_SetLogLevel_Out.retval)
  return retval_.GetNoArena();
}
inline void StdCmds_SetLogLevel_Out::set_retval(const ::std::string& value) {
  set_has_retval();
  retval_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:generated.zpb.hellomalif.StdCmds_SetLogLevel_Out.retval)
}
#if LANG_CXX11
inline void StdCmds_SetLogLevel_Out::set_retval(::std::string&& value) {
  set_has_retval();
  retval_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:generated.zpb.hellomalif.StdCmds_SetLogLevel_Out.retval)
}
#endif
inline void StdCmds_SetLogLevel_Out::set_retval(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_retval();
  retval_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:generated.zpb.hellomalif.StdCmds_SetLogLevel_Out.retval)
}
inline void StdCmds_SetLogLevel_Out::set_retval(const char* value, size_t size) {
  set_has_retval();
  retval_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:generated.zpb.hellomalif.StdCmds_SetLogLevel_Out.retval)
}
inline ::std::string* StdCmds_SetLogLevel_Out::mutable_retval() {
  set_has_retval();
  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_SetLogLevel_Out.retval)
  return retval_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* StdCmds_SetLogLevel_Out::release_retval() {
  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_SetLogLevel_Out.retval)
  if (!has_retval()) {
    return NULL;
  }
  clear_has_retval();
  return retval_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void StdCmds_SetLogLevel_Out::set_allocated_retval(::std::string* retval) {
  if (retval != NULL) {
    set_has_retval();
  } else {
    clear_has_retval();
  }
  retval_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), retval);
  // @@protoc_insertion_point(field_set_allocated:generated.zpb.hellomalif.StdCmds_SetLogLevel_Out.retval)
}
 
// optional .generated.zpb.hellomalif.ExceptionErr exExceptionErr = 2;
inline bool StdCmds_SetLogLevel_Out::has_exexceptionerr() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void StdCmds_SetLogLevel_Out::set_has_exexceptionerr() {
  _has_bits_[0] |= 0x00000002u;
}
inline void StdCmds_SetLogLevel_Out::clear_has_exexceptionerr() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void StdCmds_SetLogLevel_Out::clear_exexceptionerr() {
  if (exexceptionerr_ != NULL) exexceptionerr_->Clear();
  clear_has_exexceptionerr();
}
inline const ::generated::zpb::hellomalif::ExceptionErr& StdCmds_SetLogLevel_Out::_internal_exexceptionerr() const {
  return *exexceptionerr_;
}
inline const ::generated::zpb::hellomalif::ExceptionErr& StdCmds_SetLogLevel_Out::exexceptionerr() const {
  const ::generated::zpb::hellomalif::ExceptionErr* p = exexceptionerr_;
  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_SetLogLevel_Out.exExceptionErr)
  return p != NULL ? *p : *reinterpret_cast<const ::generated::zpb::hellomalif::ExceptionErr*>(
      &::generated::zpb::hellomalif::_ExceptionErr_default_instance_);
}
inline ::generated::zpb::hellomalif::ExceptionErr* StdCmds_SetLogLevel_Out::release_exexceptionerr() {
  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_SetLogLevel_Out.exExceptionErr)
  clear_has_exexceptionerr();
  ::generated::zpb::hellomalif::ExceptionErr* temp = exexceptionerr_;
  exexceptionerr_ = NULL;
  return temp;
}
inline ::generated::zpb::hellomalif::ExceptionErr* StdCmds_SetLogLevel_Out::mutable_exexceptionerr() {
  set_has_exexceptionerr();
  if (exexceptionerr_ == NULL) {
    auto* p = CreateMaybeMessage<::generated::zpb::hellomalif::ExceptionErr>(GetArenaNoVirtual());
    exexceptionerr_ = p;
  }
  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_SetLogLevel_Out.exExceptionErr)
  return exexceptionerr_;
}
inline void StdCmds_SetLogLevel_Out::set_allocated_exexceptionerr(::generated::zpb::hellomalif::ExceptionErr* exexceptionerr) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete exexceptionerr_;
  }
  if (exexceptionerr) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      exexceptionerr = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, exexceptionerr, submessage_arena);
    }
    set_has_exexceptionerr();
  } else {
    clear_has_exexceptionerr();
  }
  exexceptionerr_ = exexceptionerr;
  // @@protoc_insertion_point(field_set_allocated:generated.zpb.hellomalif.StdCmds_SetLogLevel_Out.exExceptionErr)
}
 
// -------------------------------------------------------------------
 
// StdCmds_Return
 
// optional .generated.zpb.hellomalif.StdCmds_Init_Out Init = 1;
inline bool StdCmds_Return::has_init() const {
  return reply_case() == kInit;
}
inline void StdCmds_Return::set_has_init() {
  _oneof_case_[0] = kInit;
}
inline void StdCmds_Return::clear_init() {
  if (has_init()) {
    delete reply_.init_;
    clear_has_reply();
  }
}
inline const ::generated::zpb::hellomalif::StdCmds_Init_Out& StdCmds_Return::_internal_init() const {
  return *reply_.init_;
}
inline ::generated::zpb::hellomalif::StdCmds_Init_Out* StdCmds_Return::release_init() {
  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Return.Init)
  if (has_init()) {
    clear_has_reply();
      ::generated::zpb::hellomalif::StdCmds_Init_Out* temp = reply_.init_;
    reply_.init_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::generated::zpb::hellomalif::StdCmds_Init_Out& StdCmds_Return::init() const {
  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Return.Init)
  return has_init()
      ? *reply_.init_
      : *reinterpret_cast< ::generated::zpb::hellomalif::StdCmds_Init_Out*>(&::generated::zpb::hellomalif::_StdCmds_Init_Out_default_instance_);
}
inline ::generated::zpb::hellomalif::StdCmds_Init_Out* StdCmds_Return::mutable_init() {
  if (!has_init()) {
    clear_reply();
    set_has_init();
    reply_.init_ = CreateMaybeMessage< ::generated::zpb::hellomalif::StdCmds_Init_Out >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Return.Init)
  return reply_.init_;
}
 
// optional .generated.zpb.hellomalif.StdCmds_Reset_Out Reset = 2;
inline bool StdCmds_Return::has_reset() const {
  return reply_case() == kReset;
}
inline void StdCmds_Return::set_has_reset() {
  _oneof_case_[0] = kReset;
}
inline void StdCmds_Return::clear_reset() {
  if (has_reset()) {
    delete reply_.reset_;
    clear_has_reply();
  }
}
inline const ::generated::zpb::hellomalif::StdCmds_Reset_Out& StdCmds_Return::_internal_reset() const {
  return *reply_.reset_;
}
inline ::generated::zpb::hellomalif::StdCmds_Reset_Out* StdCmds_Return::release_reset() {
  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Return.Reset)
  if (has_reset()) {
    clear_has_reply();
      ::generated::zpb::hellomalif::StdCmds_Reset_Out* temp = reply_.reset_;
    reply_.reset_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::generated::zpb::hellomalif::StdCmds_Reset_Out& StdCmds_Return::reset() const {
  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Return.Reset)
  return has_reset()
      ? *reply_.reset_
      : *reinterpret_cast< ::generated::zpb::hellomalif::StdCmds_Reset_Out*>(&::generated::zpb::hellomalif::_StdCmds_Reset_Out_default_instance_);
}
inline ::generated::zpb::hellomalif::StdCmds_Reset_Out* StdCmds_Return::mutable_reset() {
  if (!has_reset()) {
    clear_reply();
    set_has_reset();
    reply_.reset_ = CreateMaybeMessage< ::generated::zpb::hellomalif::StdCmds_Reset_Out >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Return.Reset)
  return reply_.reset_;
}
 
// optional .generated.zpb.hellomalif.StdCmds_Enable_Out Enable = 3;
inline bool StdCmds_Return::has_enable() const {
  return reply_case() == kEnable;
}
inline void StdCmds_Return::set_has_enable() {
  _oneof_case_[0] = kEnable;
}
inline void StdCmds_Return::clear_enable() {
  if (has_enable()) {
    delete reply_.enable_;
    clear_has_reply();
  }
}
inline const ::generated::zpb::hellomalif::StdCmds_Enable_Out& StdCmds_Return::_internal_enable() const {
  return *reply_.enable_;
}
inline ::generated::zpb::hellomalif::StdCmds_Enable_Out* StdCmds_Return::release_enable() {
  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Return.Enable)
  if (has_enable()) {
    clear_has_reply();
      ::generated::zpb::hellomalif::StdCmds_Enable_Out* temp = reply_.enable_;
    reply_.enable_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::generated::zpb::hellomalif::StdCmds_Enable_Out& StdCmds_Return::enable() const {
  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Return.Enable)
  return has_enable()
      ? *reply_.enable_
      : *reinterpret_cast< ::generated::zpb::hellomalif::StdCmds_Enable_Out*>(&::generated::zpb::hellomalif::_StdCmds_Enable_Out_default_instance_);
}
inline ::generated::zpb::hellomalif::StdCmds_Enable_Out* StdCmds_Return::mutable_enable() {
  if (!has_enable()) {
    clear_reply();
    set_has_enable();
    reply_.enable_ = CreateMaybeMessage< ::generated::zpb::hellomalif::StdCmds_Enable_Out >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Return.Enable)
  return reply_.enable_;
}
 
// optional .generated.zpb.hellomalif.StdCmds_Disable_Out Disable = 4;
inline bool StdCmds_Return::has_disable() const {
  return reply_case() == kDisable;
}
inline void StdCmds_Return::set_has_disable() {
  _oneof_case_[0] = kDisable;
}
inline void StdCmds_Return::clear_disable() {
  if (has_disable()) {
    delete reply_.disable_;
    clear_has_reply();
  }
}
inline const ::generated::zpb::hellomalif::StdCmds_Disable_Out& StdCmds_Return::_internal_disable() const {
  return *reply_.disable_;
}
inline ::generated::zpb::hellomalif::StdCmds_Disable_Out* StdCmds_Return::release_disable() {
  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Return.Disable)
  if (has_disable()) {
    clear_has_reply();
      ::generated::zpb::hellomalif::StdCmds_Disable_Out* temp = reply_.disable_;
    reply_.disable_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::generated::zpb::hellomalif::StdCmds_Disable_Out& StdCmds_Return::disable() const {
  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Return.Disable)
  return has_disable()
      ? *reply_.disable_
      : *reinterpret_cast< ::generated::zpb::hellomalif::StdCmds_Disable_Out*>(&::generated::zpb::hellomalif::_StdCmds_Disable_Out_default_instance_);
}
inline ::generated::zpb::hellomalif::StdCmds_Disable_Out* StdCmds_Return::mutable_disable() {
  if (!has_disable()) {
    clear_reply();
    set_has_disable();
    reply_.disable_ = CreateMaybeMessage< ::generated::zpb::hellomalif::StdCmds_Disable_Out >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Return.Disable)
  return reply_.disable_;
}
 
// optional .generated.zpb.hellomalif.StdCmds_GetState_Out GetState = 5;
inline bool StdCmds_Return::has_getstate() const {
  return reply_case() == kGetState;
}
inline void StdCmds_Return::set_has_getstate() {
  _oneof_case_[0] = kGetState;
}
inline void StdCmds_Return::clear_getstate() {
  if (has_getstate()) {
    delete reply_.getstate_;
    clear_has_reply();
  }
}
inline const ::generated::zpb::hellomalif::StdCmds_GetState_Out& StdCmds_Return::_internal_getstate() const {
  return *reply_.getstate_;
}
inline ::generated::zpb::hellomalif::StdCmds_GetState_Out* StdCmds_Return::release_getstate() {
  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Return.GetState)
  if (has_getstate()) {
    clear_has_reply();
      ::generated::zpb::hellomalif::StdCmds_GetState_Out* temp = reply_.getstate_;
    reply_.getstate_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::generated::zpb::hellomalif::StdCmds_GetState_Out& StdCmds_Return::getstate() const {
  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Return.GetState)
  return has_getstate()
      ? *reply_.getstate_
      : *reinterpret_cast< ::generated::zpb::hellomalif::StdCmds_GetState_Out*>(&::generated::zpb::hellomalif::_StdCmds_GetState_Out_default_instance_);
}
inline ::generated::zpb::hellomalif::StdCmds_GetState_Out* StdCmds_Return::mutable_getstate() {
  if (!has_getstate()) {
    clear_reply();
    set_has_getstate();
    reply_.getstate_ = CreateMaybeMessage< ::generated::zpb::hellomalif::StdCmds_GetState_Out >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Return.GetState)
  return reply_.getstate_;
}
 
// optional .generated.zpb.hellomalif.StdCmds_GetStatus_Out GetStatus = 6;
inline bool StdCmds_Return::has_getstatus() const {
  return reply_case() == kGetStatus;
}
inline void StdCmds_Return::set_has_getstatus() {
  _oneof_case_[0] = kGetStatus;
}
inline void StdCmds_Return::clear_getstatus() {
  if (has_getstatus()) {
    delete reply_.getstatus_;
    clear_has_reply();
  }
}
inline const ::generated::zpb::hellomalif::StdCmds_GetStatus_Out& StdCmds_Return::_internal_getstatus() const {
  return *reply_.getstatus_;
}
inline ::generated::zpb::hellomalif::StdCmds_GetStatus_Out* StdCmds_Return::release_getstatus() {
  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Return.GetStatus)
  if (has_getstatus()) {
    clear_has_reply();
      ::generated::zpb::hellomalif::StdCmds_GetStatus_Out* temp = reply_.getstatus_;
    reply_.getstatus_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::generated::zpb::hellomalif::StdCmds_GetStatus_Out& StdCmds_Return::getstatus() const {
  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Return.GetStatus)
  return has_getstatus()
      ? *reply_.getstatus_
      : *reinterpret_cast< ::generated::zpb::hellomalif::StdCmds_GetStatus_Out*>(&::generated::zpb::hellomalif::_StdCmds_GetStatus_Out_default_instance_);
}
inline ::generated::zpb::hellomalif::StdCmds_GetStatus_Out* StdCmds_Return::mutable_getstatus() {
  if (!has_getstatus()) {
    clear_reply();
    set_has_getstatus();
    reply_.getstatus_ = CreateMaybeMessage< ::generated::zpb::hellomalif::StdCmds_GetStatus_Out >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Return.GetStatus)
  return reply_.getstatus_;
}
 
// optional .generated.zpb.hellomalif.StdCmds_GetVersion_Out GetVersion = 7;
inline bool StdCmds_Return::has_getversion() const {
  return reply_case() == kGetVersion;
}
inline void StdCmds_Return::set_has_getversion() {
  _oneof_case_[0] = kGetVersion;
}
inline void StdCmds_Return::clear_getversion() {
  if (has_getversion()) {
    delete reply_.getversion_;
    clear_has_reply();
  }
}
inline const ::generated::zpb::hellomalif::StdCmds_GetVersion_Out& StdCmds_Return::_internal_getversion() const {
  return *reply_.getversion_;
}
inline ::generated::zpb::hellomalif::StdCmds_GetVersion_Out* StdCmds_Return::release_getversion() {
  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Return.GetVersion)
  if (has_getversion()) {
    clear_has_reply();
      ::generated::zpb::hellomalif::StdCmds_GetVersion_Out* temp = reply_.getversion_;
    reply_.getversion_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::generated::zpb::hellomalif::StdCmds_GetVersion_Out& StdCmds_Return::getversion() const {
  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Return.GetVersion)
  return has_getversion()
      ? *reply_.getversion_
      : *reinterpret_cast< ::generated::zpb::hellomalif::StdCmds_GetVersion_Out*>(&::generated::zpb::hellomalif::_StdCmds_GetVersion_Out_default_instance_);
}
inline ::generated::zpb::hellomalif::StdCmds_GetVersion_Out* StdCmds_Return::mutable_getversion() {
  if (!has_getversion()) {
    clear_reply();
    set_has_getversion();
    reply_.getversion_ = CreateMaybeMessage< ::generated::zpb::hellomalif::StdCmds_GetVersion_Out >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Return.GetVersion)
  return reply_.getversion_;
}
 
// optional .generated.zpb.hellomalif.StdCmds_Stop_Out Stop = 8;
inline bool StdCmds_Return::has_stop() const {
  return reply_case() == kStop;
}
inline void StdCmds_Return::set_has_stop() {
  _oneof_case_[0] = kStop;
}
inline void StdCmds_Return::clear_stop() {
  if (has_stop()) {
    delete reply_.stop_;
    clear_has_reply();
  }
}
inline const ::generated::zpb::hellomalif::StdCmds_Stop_Out& StdCmds_Return::_internal_stop() const {
  return *reply_.stop_;
}
inline ::generated::zpb::hellomalif::StdCmds_Stop_Out* StdCmds_Return::release_stop() {
  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Return.Stop)
  if (has_stop()) {
    clear_has_reply();
      ::generated::zpb::hellomalif::StdCmds_Stop_Out* temp = reply_.stop_;
    reply_.stop_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::generated::zpb::hellomalif::StdCmds_Stop_Out& StdCmds_Return::stop() const {
  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Return.Stop)
  return has_stop()
      ? *reply_.stop_
      : *reinterpret_cast< ::generated::zpb::hellomalif::StdCmds_Stop_Out*>(&::generated::zpb::hellomalif::_StdCmds_Stop_Out_default_instance_);
}
inline ::generated::zpb::hellomalif::StdCmds_Stop_Out* StdCmds_Return::mutable_stop() {
  if (!has_stop()) {
    clear_reply();
    set_has_stop();
    reply_.stop_ = CreateMaybeMessage< ::generated::zpb::hellomalif::StdCmds_Stop_Out >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Return.Stop)
  return reply_.stop_;
}
 
// optional .generated.zpb.hellomalif.StdCmds_Exit_Out Exit = 9;
inline bool StdCmds_Return::has_exit() const {
  return reply_case() == kExit;
}
inline void StdCmds_Return::set_has_exit() {
  _oneof_case_[0] = kExit;
}
inline void StdCmds_Return::clear_exit() {
  if (has_exit()) {
    delete reply_.exit_;
    clear_has_reply();
  }
}
inline const ::generated::zpb::hellomalif::StdCmds_Exit_Out& StdCmds_Return::_internal_exit() const {
  return *reply_.exit_;
}
inline ::generated::zpb::hellomalif::StdCmds_Exit_Out* StdCmds_Return::release_exit() {
  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Return.Exit)
  if (has_exit()) {
    clear_has_reply();
      ::generated::zpb::hellomalif::StdCmds_Exit_Out* temp = reply_.exit_;
    reply_.exit_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::generated::zpb::hellomalif::StdCmds_Exit_Out& StdCmds_Return::exit() const {
  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Return.Exit)
  return has_exit()
      ? *reply_.exit_
      : *reinterpret_cast< ::generated::zpb::hellomalif::StdCmds_Exit_Out*>(&::generated::zpb::hellomalif::_StdCmds_Exit_Out_default_instance_);
}
inline ::generated::zpb::hellomalif::StdCmds_Exit_Out* StdCmds_Return::mutable_exit() {
  if (!has_exit()) {
    clear_reply();
    set_has_exit();
    reply_.exit_ = CreateMaybeMessage< ::generated::zpb::hellomalif::StdCmds_Exit_Out >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Return.Exit)
  return reply_.exit_;
}
 
// optional .generated.zpb.hellomalif.StdCmds_SetLogLevel_Out SetLogLevel = 10;
inline bool StdCmds_Return::has_setloglevel() const {
  return reply_case() == kSetLogLevel;
}
inline void StdCmds_Return::set_has_setloglevel() {
  _oneof_case_[0] = kSetLogLevel;
}
inline void StdCmds_Return::clear_setloglevel() {
  if (has_setloglevel()) {
    delete reply_.setloglevel_;
    clear_has_reply();
  }
}
inline const ::generated::zpb::hellomalif::StdCmds_SetLogLevel_Out& StdCmds_Return::_internal_setloglevel() const {
  return *reply_.setloglevel_;
}
inline ::generated::zpb::hellomalif::StdCmds_SetLogLevel_Out* StdCmds_Return::release_setloglevel() {
  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Return.SetLogLevel)
  if (has_setloglevel()) {
    clear_has_reply();
      ::generated::zpb::hellomalif::StdCmds_SetLogLevel_Out* temp = reply_.setloglevel_;
    reply_.setloglevel_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::generated::zpb::hellomalif::StdCmds_SetLogLevel_Out& StdCmds_Return::setloglevel() const {
  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Return.SetLogLevel)
  return has_setloglevel()
      ? *reply_.setloglevel_
      : *reinterpret_cast< ::generated::zpb::hellomalif::StdCmds_SetLogLevel_Out*>(&::generated::zpb::hellomalif::_StdCmds_SetLogLevel_Out_default_instance_);
}
inline ::generated::zpb::hellomalif::StdCmds_SetLogLevel_Out* StdCmds_Return::mutable_setloglevel() {
  if (!has_setloglevel()) {
    clear_reply();
    set_has_setloglevel();
    reply_.setloglevel_ = CreateMaybeMessage< ::generated::zpb::hellomalif::StdCmds_SetLogLevel_Out >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Return.SetLogLevel)
  return reply_.setloglevel_;
}
 
inline bool StdCmds_Return::has_reply() const {
  return reply_case() != REPLY_NOT_SET;
}
inline void StdCmds_Return::clear_has_reply() {
  _oneof_case_[0] = REPLY_NOT_SET;
}
inline StdCmds_Return::ReplyCase StdCmds_Return::reply_case() const {
  return StdCmds_Return::ReplyCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------
 
// StdCmds_Reply
 
// required .elt.mal.zpb.rr.ReplyHeader header = 1;
inline bool StdCmds_Reply::has_header() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void StdCmds_Reply::set_has_header() {
  _has_bits_[0] |= 0x00000001u;
}
inline void StdCmds_Reply::clear_has_header() {
  _has_bits_[0] &= ~0x00000001u;
}
inline const ::elt::mal::zpb::rr::ReplyHeader& StdCmds_Reply::_internal_header() const {
  return *header_;
}
inline const ::elt::mal::zpb::rr::ReplyHeader& StdCmds_Reply::header() const {
  const ::elt::mal::zpb::rr::ReplyHeader* p = header_;
  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Reply.header)
  return p != NULL ? *p : *reinterpret_cast<const ::elt::mal::zpb::rr::ReplyHeader*>(
      &::elt::mal::zpb::rr::_ReplyHeader_default_instance_);
}
inline ::elt::mal::zpb::rr::ReplyHeader* StdCmds_Reply::release_header() {
  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Reply.header)
  clear_has_header();
  ::elt::mal::zpb::rr::ReplyHeader* temp = header_;
  header_ = NULL;
  return temp;
}
inline ::elt::mal::zpb::rr::ReplyHeader* StdCmds_Reply::mutable_header() {
  set_has_header();
  if (header_ == NULL) {
    auto* p = CreateMaybeMessage<::elt::mal::zpb::rr::ReplyHeader>(GetArenaNoVirtual());
    header_ = p;
  }
  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Reply.header)
  return header_;
}
inline void StdCmds_Reply::set_allocated_header(::elt::mal::zpb::rr::ReplyHeader* header) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete reinterpret_cast< ::google::protobuf::MessageLite*>(header_);
  }
  if (header) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      header = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, header, submessage_arena);
    }
    set_has_header();
  } else {
    clear_has_header();
  }
  header_ = header;
  // @@protoc_insertion_point(field_set_allocated:generated.zpb.hellomalif.StdCmds_Reply.header)
}
 
// optional .generated.zpb.hellomalif.StdCmds_Return data = 2;
inline bool StdCmds_Reply::has_data() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void StdCmds_Reply::set_has_data() {
  _has_bits_[0] |= 0x00000002u;
}
inline void StdCmds_Reply::clear_has_data() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void StdCmds_Reply::clear_data() {
  if (data_ != NULL) data_->Clear();
  clear_has_data();
}
inline const ::generated::zpb::hellomalif::StdCmds_Return& StdCmds_Reply::_internal_data() const {
  return *data_;
}
inline const ::generated::zpb::hellomalif::StdCmds_Return& StdCmds_Reply::data() const {
  const ::generated::zpb::hellomalif::StdCmds_Return* p = data_;
  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Reply.data)
  return p != NULL ? *p : *reinterpret_cast<const ::generated::zpb::hellomalif::StdCmds_Return*>(
      &::generated::zpb::hellomalif::_StdCmds_Return_default_instance_);
}
inline ::generated::zpb::hellomalif::StdCmds_Return* StdCmds_Reply::release_data() {
  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Reply.data)
  clear_has_data();
  ::generated::zpb::hellomalif::StdCmds_Return* temp = data_;
  data_ = NULL;
  return temp;
}
inline ::generated::zpb::hellomalif::StdCmds_Return* StdCmds_Reply::mutable_data() {
  set_has_data();
  if (data_ == NULL) {
    auto* p = CreateMaybeMessage<::generated::zpb::hellomalif::StdCmds_Return>(GetArenaNoVirtual());
    data_ = p;
  }
  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Reply.data)
  return data_;
}
inline void StdCmds_Reply::set_allocated_data(::generated::zpb::hellomalif::StdCmds_Return* data) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete data_;
  }
  if (data) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      data = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, data, submessage_arena);
    }
    set_has_data();
  } else {
    clear_has_data();
  }
  data_ = data;
  // @@protoc_insertion_point(field_set_allocated:generated.zpb.hellomalif.StdCmds_Reply.data)
}
 
#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
 
// @@protoc_insertion_point(namespace_scope)
 
}  // namespace hellomalif
}  // namespace zpb
}  // namespace generated
 
// @@protoc_insertion_point(global_scope)
 
#endif  // PROTOBUF_INCLUDED_hellomalif_2eproto