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

#ifndef GOOGLE_PROTOBUF_INCLUDED_FlashCommandsPb_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_FlashCommandsPb_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3010000
#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 3010001 < 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/port_undef.inc>
#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/generated_message_reflection.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 "DiagComDataModelsPb.pb.h"
#include "FlashDataModelsPb.pb.h"
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_FlashCommandsPb_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_FlashCommandsPb_2eproto {
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxillaryParseTableField aux[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[24]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_FlashCommandsPb_2eproto;
namespace OpenTestSystem {
namespace OtxDiagManager {
namespace Common {
class BlockIsValidForAudiencePb;
class BlockIsValidForAudiencePbDefaultTypeInternal;
extern BlockIsValidForAudiencePbDefaultTypeInternal _BlockIsValidForAudiencePb_default_instance_;
class CreateFlashJobByNamePb;
class CreateFlashJobByNamePbDefaultTypeInternal;
extern CreateFlashJobByNamePbDefaultTypeInternal _CreateFlashJobByNamePb_default_instance_;
class CreateFlashJobBySemanticPb;
class CreateFlashJobBySemanticPbDefaultTypeInternal;
extern CreateFlashJobBySemanticPbDefaultTypeInternal _CreateFlashJobBySemanticPb_default_instance_;
class CreateFlashJobPb;
class CreateFlashJobPbDefaultTypeInternal;
extern CreateFlashJobPbDefaultTypeInternal _CreateFlashJobPb_default_instance_;
class GetChecksumPb;
class GetChecksumPbDefaultTypeInternal;
extern GetChecksumPbDefaultTypeInternal _GetChecksumPb_default_instance_;
class GetCompressedSizePb;
class GetCompressedSizePbDefaultTypeInternal;
extern GetCompressedSizePbDefaultTypeInternal _GetCompressedSizePb_default_instance_;
class GetCompressionEncryptionPb;
class GetCompressionEncryptionPbDefaultTypeInternal;
extern GetCompressionEncryptionPbDefaultTypeInternal _GetCompressionEncryptionPb_default_instance_;
class GetDownloadDataPb;
class GetDownloadDataPbDefaultTypeInternal;
extern GetDownloadDataPbDefaultTypeInternal _GetDownloadDataPb_default_instance_;
class GetFlashSessionPb;
class GetFlashSessionPbDefaultTypeInternal;
extern GetFlashSessionPbDefaultTypeInternal _GetFlashSessionPb_default_instance_;
class GetListOfValidFlashSessionsPb;
class GetListOfValidFlashSessionsPbDefaultTypeInternal;
extern GetListOfValidFlashSessionsPbDefaultTypeInternal _GetListOfValidFlashSessionsPb_default_instance_;
class GetLogicalBlockIDPb;
class GetLogicalBlockIDPbDefaultTypeInternal;
extern GetLogicalBlockIDPbDefaultTypeInternal _GetLogicalBlockIDPb_default_instance_;
class GetNumberOfBlocksPb;
class GetNumberOfBlocksPbDefaultTypeInternal;
extern GetNumberOfBlocksPbDefaultTypeInternal _GetNumberOfBlocksPb_default_instance_;
class GetNumberOfOwnIdentsPb;
class GetNumberOfOwnIdentsPbDefaultTypeInternal;
extern GetNumberOfOwnIdentsPbDefaultTypeInternal _GetNumberOfOwnIdentsPb_default_instance_;
class GetNumberOfSecuritiesPb;
class GetNumberOfSecuritiesPbDefaultTypeInternal;
extern GetNumberOfSecuritiesPbDefaultTypeInternal _GetNumberOfSecuritiesPb_default_instance_;
class GetNumberOfSegmentsPb;
class GetNumberOfSegmentsPbDefaultTypeInternal;
extern GetNumberOfSegmentsPbDefaultTypeInternal _GetNumberOfSegmentsPb_default_instance_;
class GetOwnIdentFromEcuPb;
class GetOwnIdentFromEcuPbDefaultTypeInternal;
extern GetOwnIdentFromEcuPbDefaultTypeInternal _GetOwnIdentFromEcuPb_default_instance_;
class GetOwnIdentPb;
class GetOwnIdentPbDefaultTypeInternal;
extern GetOwnIdentPbDefaultTypeInternal _GetOwnIdentPb_default_instance_;
class GetSecurityMethodPb;
class GetSecurityMethodPbDefaultTypeInternal;
extern GetSecurityMethodPbDefaultTypeInternal _GetSecurityMethodPb_default_instance_;
class GetSignaturePb;
class GetSignaturePbDefaultTypeInternal;
extern GetSignaturePbDefaultTypeInternal _GetSignaturePb_default_instance_;
class GetStartAddressPb;
class GetStartAddressPbDefaultTypeInternal;
extern GetStartAddressPbDefaultTypeInternal _GetStartAddressPb_default_instance_;
class GetTypePb;
class GetTypePbDefaultTypeInternal;
extern GetTypePbDefaultTypeInternal _GetTypePb_default_instance_;
class GetUncompressedSizePb;
class GetUncompressedSizePbDefaultTypeInternal;
extern GetUncompressedSizePbDefaultTypeInternal _GetUncompressedSizePb_default_instance_;
class GetValidityPb;
class GetValidityPbDefaultTypeInternal;
extern GetValidityPbDefaultTypeInternal _GetValidityPb_default_instance_;
class SetFlashSessionPb;
class SetFlashSessionPbDefaultTypeInternal;
extern SetFlashSessionPbDefaultTypeInternal _SetFlashSessionPb_default_instance_;
}  // namespace Common
}  // namespace OtxDiagManager
}  // namespace OpenTestSystem
PROTOBUF_NAMESPACE_OPEN
template<> ::OpenTestSystem::OtxDiagManager::Common::BlockIsValidForAudiencePb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::BlockIsValidForAudiencePb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::CreateFlashJobByNamePb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::CreateFlashJobByNamePb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::CreateFlashJobBySemanticPb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::CreateFlashJobBySemanticPb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::CreateFlashJobPb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::CreateFlashJobPb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::GetChecksumPb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::GetChecksumPb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::GetCompressedSizePb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::GetCompressedSizePb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::GetCompressionEncryptionPb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::GetCompressionEncryptionPb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::GetDownloadDataPb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::GetDownloadDataPb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::GetFlashSessionPb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::GetFlashSessionPb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::GetListOfValidFlashSessionsPb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::GetListOfValidFlashSessionsPb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::GetLogicalBlockIDPb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::GetLogicalBlockIDPb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::GetNumberOfBlocksPb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::GetNumberOfBlocksPb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::GetNumberOfOwnIdentsPb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::GetNumberOfOwnIdentsPb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::GetNumberOfSecuritiesPb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::GetNumberOfSecuritiesPb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::GetNumberOfSegmentsPb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::GetNumberOfSegmentsPb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::GetOwnIdentFromEcuPb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::GetOwnIdentFromEcuPb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::GetOwnIdentPb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::GetOwnIdentPb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::GetSecurityMethodPb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::GetSecurityMethodPb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::GetSignaturePb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::GetSignaturePb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::GetStartAddressPb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::GetStartAddressPb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::GetTypePb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::GetTypePb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::GetUncompressedSizePb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::GetUncompressedSizePb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::GetValidityPb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::GetValidityPb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::SetFlashSessionPb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::SetFlashSessionPb>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace OpenTestSystem {
namespace OtxDiagManager {
namespace Common {

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

class GetListOfValidFlashSessionsPb :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:OpenTestSystem.OtxDiagManager.Common.GetListOfValidFlashSessionsPb) */ {
 public:
  GetListOfValidFlashSessionsPb();
  virtual ~GetListOfValidFlashSessionsPb();

  GetListOfValidFlashSessionsPb(const GetListOfValidFlashSessionsPb& from);
  GetListOfValidFlashSessionsPb(GetListOfValidFlashSessionsPb&& from) noexcept
    : GetListOfValidFlashSessionsPb() {
    *this = ::std::move(from);
  }

  inline GetListOfValidFlashSessionsPb& operator=(const GetListOfValidFlashSessionsPb& from) {
    CopyFrom(from);
    return *this;
  }
  inline GetListOfValidFlashSessionsPb& operator=(GetListOfValidFlashSessionsPb&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const GetListOfValidFlashSessionsPb& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const GetListOfValidFlashSessionsPb* internal_default_instance() {
    return reinterpret_cast<const GetListOfValidFlashSessionsPb*>(
               &_GetListOfValidFlashSessionsPb_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(GetListOfValidFlashSessionsPb& a, GetListOfValidFlashSessionsPb& b) {
    a.Swap(&b);
  }
  inline void Swap(GetListOfValidFlashSessionsPb* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline GetListOfValidFlashSessionsPb* New() const final {
    return CreateMaybeMessage<GetListOfValidFlashSessionsPb>(nullptr);
  }

  GetListOfValidFlashSessionsPb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<GetListOfValidFlashSessionsPb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const GetListOfValidFlashSessionsPb& from);
  void MergeFrom(const GetListOfValidFlashSessionsPb& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(GetListOfValidFlashSessionsPb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.GetListOfValidFlashSessionsPb";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_FlashCommandsPb_2eproto);
    return ::descriptor_table_FlashCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kComChannelFieldNumber = 1,
    kAudienceFieldNumber = 2,
    kDirectionFieldNumber = 3,
  };
  // .OpenTestSystem.OtxDiagManager.Common.DComChannelPb ComChannel = 1;
  bool has_comchannel() const;
  private:
  bool _internal_has_comchannel() const;
  public:
  void clear_comchannel();
  const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& comchannel() const;
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* release_comchannel();
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* mutable_comchannel();
  void set_allocated_comchannel(::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* comchannel);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& _internal_comchannel() const;
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* _internal_mutable_comchannel();
  public:

  // .OpenTestSystem.OtxDiagManager.Common.DAudiencesPb Audience = 2;
  void clear_audience();
  ::OpenTestSystem::OtxDiagManager::Common::DAudiencesPb audience() const;
  void set_audience(::OpenTestSystem::OtxDiagManager::Common::DAudiencesPb value);
  private:
  ::OpenTestSystem::OtxDiagManager::Common::DAudiencesPb _internal_audience() const;
  void _internal_set_audience(::OpenTestSystem::OtxDiagManager::Common::DAudiencesPb value);
  public:

  // .OpenTestSystem.OtxDiagManager.Common.DDirectionsPb Direction = 3;
  void clear_direction();
  ::OpenTestSystem::OtxDiagManager::Common::DDirectionsPb direction() const;
  void set_direction(::OpenTestSystem::OtxDiagManager::Common::DDirectionsPb value);
  private:
  ::OpenTestSystem::OtxDiagManager::Common::DDirectionsPb _internal_direction() const;
  void _internal_set_direction(::OpenTestSystem::OtxDiagManager::Common::DDirectionsPb value);
  public:

  // @@protoc_insertion_point(class_scope:OpenTestSystem.OtxDiagManager.Common.GetListOfValidFlashSessionsPb)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* comchannel_;
  int audience_;
  int direction_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_FlashCommandsPb_2eproto;
};
// -------------------------------------------------------------------

class GetFlashSessionPb :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:OpenTestSystem.OtxDiagManager.Common.GetFlashSessionPb) */ {
 public:
  GetFlashSessionPb();
  virtual ~GetFlashSessionPb();

  GetFlashSessionPb(const GetFlashSessionPb& from);
  GetFlashSessionPb(GetFlashSessionPb&& from) noexcept
    : GetFlashSessionPb() {
    *this = ::std::move(from);
  }

  inline GetFlashSessionPb& operator=(const GetFlashSessionPb& from) {
    CopyFrom(from);
    return *this;
  }
  inline GetFlashSessionPb& operator=(GetFlashSessionPb&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const GetFlashSessionPb& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const GetFlashSessionPb* internal_default_instance() {
    return reinterpret_cast<const GetFlashSessionPb*>(
               &_GetFlashSessionPb_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(GetFlashSessionPb& a, GetFlashSessionPb& b) {
    a.Swap(&b);
  }
  inline void Swap(GetFlashSessionPb* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline GetFlashSessionPb* New() const final {
    return CreateMaybeMessage<GetFlashSessionPb>(nullptr);
  }

  GetFlashSessionPb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<GetFlashSessionPb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const GetFlashSessionPb& from);
  void MergeFrom(const GetFlashSessionPb& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(GetFlashSessionPb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.GetFlashSessionPb";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_FlashCommandsPb_2eproto);
    return ::descriptor_table_FlashCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kSessionIdFieldNumber = 1,
  };
  // string SessionId = 1;
  void clear_sessionid();
  const std::string& sessionid() const;
  void set_sessionid(const std::string& value);
  void set_sessionid(std::string&& value);
  void set_sessionid(const char* value);
  void set_sessionid(const char* value, size_t size);
  std::string* mutable_sessionid();
  std::string* release_sessionid();
  void set_allocated_sessionid(std::string* sessionid);
  private:
  const std::string& _internal_sessionid() const;
  void _internal_set_sessionid(const std::string& value);
  std::string* _internal_mutable_sessionid();
  public:

  // @@protoc_insertion_point(class_scope:OpenTestSystem.OtxDiagManager.Common.GetFlashSessionPb)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sessionid_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_FlashCommandsPb_2eproto;
};
// -------------------------------------------------------------------

class GetNumberOfBlocksPb :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:OpenTestSystem.OtxDiagManager.Common.GetNumberOfBlocksPb) */ {
 public:
  GetNumberOfBlocksPb();
  virtual ~GetNumberOfBlocksPb();

  GetNumberOfBlocksPb(const GetNumberOfBlocksPb& from);
  GetNumberOfBlocksPb(GetNumberOfBlocksPb&& from) noexcept
    : GetNumberOfBlocksPb() {
    *this = ::std::move(from);
  }

  inline GetNumberOfBlocksPb& operator=(const GetNumberOfBlocksPb& from) {
    CopyFrom(from);
    return *this;
  }
  inline GetNumberOfBlocksPb& operator=(GetNumberOfBlocksPb&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const GetNumberOfBlocksPb& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const GetNumberOfBlocksPb* internal_default_instance() {
    return reinterpret_cast<const GetNumberOfBlocksPb*>(
               &_GetNumberOfBlocksPb_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(GetNumberOfBlocksPb& a, GetNumberOfBlocksPb& b) {
    a.Swap(&b);
  }
  inline void Swap(GetNumberOfBlocksPb* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline GetNumberOfBlocksPb* New() const final {
    return CreateMaybeMessage<GetNumberOfBlocksPb>(nullptr);
  }

  GetNumberOfBlocksPb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<GetNumberOfBlocksPb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const GetNumberOfBlocksPb& from);
  void MergeFrom(const GetNumberOfBlocksPb& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(GetNumberOfBlocksPb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.GetNumberOfBlocksPb";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_FlashCommandsPb_2eproto);
    return ::descriptor_table_FlashCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kFlashSessionFieldNumber = 1,
  };
  // .OpenTestSystem.OtxDiagManager.Common.DFlashSessionPb FlashSession = 1;
  bool has_flashsession() const;
  private:
  bool _internal_has_flashsession() const;
  public:
  void clear_flashsession();
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& flashsession() const;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* release_flashsession();
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* mutable_flashsession();
  void set_allocated_flashsession(::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& _internal_flashsession() const;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* _internal_mutable_flashsession();
  public:

  // @@protoc_insertion_point(class_scope:OpenTestSystem.OtxDiagManager.Common.GetNumberOfBlocksPb)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_FlashCommandsPb_2eproto;
};
// -------------------------------------------------------------------

class GetNumberOfSegmentsPb :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:OpenTestSystem.OtxDiagManager.Common.GetNumberOfSegmentsPb) */ {
 public:
  GetNumberOfSegmentsPb();
  virtual ~GetNumberOfSegmentsPb();

  GetNumberOfSegmentsPb(const GetNumberOfSegmentsPb& from);
  GetNumberOfSegmentsPb(GetNumberOfSegmentsPb&& from) noexcept
    : GetNumberOfSegmentsPb() {
    *this = ::std::move(from);
  }

  inline GetNumberOfSegmentsPb& operator=(const GetNumberOfSegmentsPb& from) {
    CopyFrom(from);
    return *this;
  }
  inline GetNumberOfSegmentsPb& operator=(GetNumberOfSegmentsPb&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const GetNumberOfSegmentsPb& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const GetNumberOfSegmentsPb* internal_default_instance() {
    return reinterpret_cast<const GetNumberOfSegmentsPb*>(
               &_GetNumberOfSegmentsPb_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(GetNumberOfSegmentsPb& a, GetNumberOfSegmentsPb& b) {
    a.Swap(&b);
  }
  inline void Swap(GetNumberOfSegmentsPb* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline GetNumberOfSegmentsPb* New() const final {
    return CreateMaybeMessage<GetNumberOfSegmentsPb>(nullptr);
  }

  GetNumberOfSegmentsPb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<GetNumberOfSegmentsPb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const GetNumberOfSegmentsPb& from);
  void MergeFrom(const GetNumberOfSegmentsPb& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(GetNumberOfSegmentsPb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.GetNumberOfSegmentsPb";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_FlashCommandsPb_2eproto);
    return ::descriptor_table_FlashCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kFlashSessionFieldNumber = 1,
    kBlockFieldNumber = 2,
  };
  // .OpenTestSystem.OtxDiagManager.Common.DFlashSessionPb FlashSession = 1;
  bool has_flashsession() const;
  private:
  bool _internal_has_flashsession() const;
  public:
  void clear_flashsession();
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& flashsession() const;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* release_flashsession();
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* mutable_flashsession();
  void set_allocated_flashsession(::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& _internal_flashsession() const;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* _internal_mutable_flashsession();
  public:

  // double Block = 2;
  void clear_block();
  double block() const;
  void set_block(double value);
  private:
  double _internal_block() const;
  void _internal_set_block(double value);
  public:

  // @@protoc_insertion_point(class_scope:OpenTestSystem.OtxDiagManager.Common.GetNumberOfSegmentsPb)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession_;
  double block_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_FlashCommandsPb_2eproto;
};
// -------------------------------------------------------------------

class GetLogicalBlockIDPb :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:OpenTestSystem.OtxDiagManager.Common.GetLogicalBlockIDPb) */ {
 public:
  GetLogicalBlockIDPb();
  virtual ~GetLogicalBlockIDPb();

  GetLogicalBlockIDPb(const GetLogicalBlockIDPb& from);
  GetLogicalBlockIDPb(GetLogicalBlockIDPb&& from) noexcept
    : GetLogicalBlockIDPb() {
    *this = ::std::move(from);
  }

  inline GetLogicalBlockIDPb& operator=(const GetLogicalBlockIDPb& from) {
    CopyFrom(from);
    return *this;
  }
  inline GetLogicalBlockIDPb& operator=(GetLogicalBlockIDPb&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const GetLogicalBlockIDPb& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const GetLogicalBlockIDPb* internal_default_instance() {
    return reinterpret_cast<const GetLogicalBlockIDPb*>(
               &_GetLogicalBlockIDPb_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  friend void swap(GetLogicalBlockIDPb& a, GetLogicalBlockIDPb& b) {
    a.Swap(&b);
  }
  inline void Swap(GetLogicalBlockIDPb* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline GetLogicalBlockIDPb* New() const final {
    return CreateMaybeMessage<GetLogicalBlockIDPb>(nullptr);
  }

  GetLogicalBlockIDPb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<GetLogicalBlockIDPb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const GetLogicalBlockIDPb& from);
  void MergeFrom(const GetLogicalBlockIDPb& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(GetLogicalBlockIDPb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.GetLogicalBlockIDPb";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_FlashCommandsPb_2eproto);
    return ::descriptor_table_FlashCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kFlashSessionFieldNumber = 1,
    kBlockFieldNumber = 2,
  };
  // .OpenTestSystem.OtxDiagManager.Common.DFlashSessionPb FlashSession = 1;
  bool has_flashsession() const;
  private:
  bool _internal_has_flashsession() const;
  public:
  void clear_flashsession();
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& flashsession() const;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* release_flashsession();
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* mutable_flashsession();
  void set_allocated_flashsession(::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& _internal_flashsession() const;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* _internal_mutable_flashsession();
  public:

  // double Block = 2;
  void clear_block();
  double block() const;
  void set_block(double value);
  private:
  double _internal_block() const;
  void _internal_set_block(double value);
  public:

  // @@protoc_insertion_point(class_scope:OpenTestSystem.OtxDiagManager.Common.GetLogicalBlockIDPb)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession_;
  double block_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_FlashCommandsPb_2eproto;
};
// -------------------------------------------------------------------

class BlockIsValidForAudiencePb :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:OpenTestSystem.OtxDiagManager.Common.BlockIsValidForAudiencePb) */ {
 public:
  BlockIsValidForAudiencePb();
  virtual ~BlockIsValidForAudiencePb();

  BlockIsValidForAudiencePb(const BlockIsValidForAudiencePb& from);
  BlockIsValidForAudiencePb(BlockIsValidForAudiencePb&& from) noexcept
    : BlockIsValidForAudiencePb() {
    *this = ::std::move(from);
  }

  inline BlockIsValidForAudiencePb& operator=(const BlockIsValidForAudiencePb& from) {
    CopyFrom(from);
    return *this;
  }
  inline BlockIsValidForAudiencePb& operator=(BlockIsValidForAudiencePb&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const BlockIsValidForAudiencePb& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const BlockIsValidForAudiencePb* internal_default_instance() {
    return reinterpret_cast<const BlockIsValidForAudiencePb*>(
               &_BlockIsValidForAudiencePb_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  friend void swap(BlockIsValidForAudiencePb& a, BlockIsValidForAudiencePb& b) {
    a.Swap(&b);
  }
  inline void Swap(BlockIsValidForAudiencePb* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline BlockIsValidForAudiencePb* New() const final {
    return CreateMaybeMessage<BlockIsValidForAudiencePb>(nullptr);
  }

  BlockIsValidForAudiencePb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<BlockIsValidForAudiencePb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const BlockIsValidForAudiencePb& from);
  void MergeFrom(const BlockIsValidForAudiencePb& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(BlockIsValidForAudiencePb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.BlockIsValidForAudiencePb";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_FlashCommandsPb_2eproto);
    return ::descriptor_table_FlashCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kFlashSessionFieldNumber = 1,
    kBlockFieldNumber = 2,
    kAudienceFieldNumber = 3,
  };
  // .OpenTestSystem.OtxDiagManager.Common.DFlashSessionPb FlashSession = 1;
  bool has_flashsession() const;
  private:
  bool _internal_has_flashsession() const;
  public:
  void clear_flashsession();
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& flashsession() const;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* release_flashsession();
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* mutable_flashsession();
  void set_allocated_flashsession(::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& _internal_flashsession() const;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* _internal_mutable_flashsession();
  public:

  // double Block = 2;
  void clear_block();
  double block() const;
  void set_block(double value);
  private:
  double _internal_block() const;
  void _internal_set_block(double value);
  public:

  // .OpenTestSystem.OtxDiagManager.Common.DAudiencesPb Audience = 3;
  void clear_audience();
  ::OpenTestSystem::OtxDiagManager::Common::DAudiencesPb audience() const;
  void set_audience(::OpenTestSystem::OtxDiagManager::Common::DAudiencesPb value);
  private:
  ::OpenTestSystem::OtxDiagManager::Common::DAudiencesPb _internal_audience() const;
  void _internal_set_audience(::OpenTestSystem::OtxDiagManager::Common::DAudiencesPb value);
  public:

  // @@protoc_insertion_point(class_scope:OpenTestSystem.OtxDiagManager.Common.BlockIsValidForAudiencePb)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession_;
  double block_;
  int audience_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_FlashCommandsPb_2eproto;
};
// -------------------------------------------------------------------

class GetNumberOfOwnIdentsPb :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:OpenTestSystem.OtxDiagManager.Common.GetNumberOfOwnIdentsPb) */ {
 public:
  GetNumberOfOwnIdentsPb();
  virtual ~GetNumberOfOwnIdentsPb();

  GetNumberOfOwnIdentsPb(const GetNumberOfOwnIdentsPb& from);
  GetNumberOfOwnIdentsPb(GetNumberOfOwnIdentsPb&& from) noexcept
    : GetNumberOfOwnIdentsPb() {
    *this = ::std::move(from);
  }

  inline GetNumberOfOwnIdentsPb& operator=(const GetNumberOfOwnIdentsPb& from) {
    CopyFrom(from);
    return *this;
  }
  inline GetNumberOfOwnIdentsPb& operator=(GetNumberOfOwnIdentsPb&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const GetNumberOfOwnIdentsPb& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const GetNumberOfOwnIdentsPb* internal_default_instance() {
    return reinterpret_cast<const GetNumberOfOwnIdentsPb*>(
               &_GetNumberOfOwnIdentsPb_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  friend void swap(GetNumberOfOwnIdentsPb& a, GetNumberOfOwnIdentsPb& b) {
    a.Swap(&b);
  }
  inline void Swap(GetNumberOfOwnIdentsPb* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline GetNumberOfOwnIdentsPb* New() const final {
    return CreateMaybeMessage<GetNumberOfOwnIdentsPb>(nullptr);
  }

  GetNumberOfOwnIdentsPb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<GetNumberOfOwnIdentsPb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const GetNumberOfOwnIdentsPb& from);
  void MergeFrom(const GetNumberOfOwnIdentsPb& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(GetNumberOfOwnIdentsPb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.GetNumberOfOwnIdentsPb";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_FlashCommandsPb_2eproto);
    return ::descriptor_table_FlashCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kFlashSessionFieldNumber = 1,
    kBlockFieldNumber = 2,
  };
  // .OpenTestSystem.OtxDiagManager.Common.DFlashSessionPb FlashSession = 1;
  bool has_flashsession() const;
  private:
  bool _internal_has_flashsession() const;
  public:
  void clear_flashsession();
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& flashsession() const;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* release_flashsession();
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* mutable_flashsession();
  void set_allocated_flashsession(::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& _internal_flashsession() const;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* _internal_mutable_flashsession();
  public:

  // double Block = 2;
  void clear_block();
  double block() const;
  void set_block(double value);
  private:
  double _internal_block() const;
  void _internal_set_block(double value);
  public:

  // @@protoc_insertion_point(class_scope:OpenTestSystem.OtxDiagManager.Common.GetNumberOfOwnIdentsPb)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession_;
  double block_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_FlashCommandsPb_2eproto;
};
// -------------------------------------------------------------------

class GetCompressionEncryptionPb :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:OpenTestSystem.OtxDiagManager.Common.GetCompressionEncryptionPb) */ {
 public:
  GetCompressionEncryptionPb();
  virtual ~GetCompressionEncryptionPb();

  GetCompressionEncryptionPb(const GetCompressionEncryptionPb& from);
  GetCompressionEncryptionPb(GetCompressionEncryptionPb&& from) noexcept
    : GetCompressionEncryptionPb() {
    *this = ::std::move(from);
  }

  inline GetCompressionEncryptionPb& operator=(const GetCompressionEncryptionPb& from) {
    CopyFrom(from);
    return *this;
  }
  inline GetCompressionEncryptionPb& operator=(GetCompressionEncryptionPb&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const GetCompressionEncryptionPb& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const GetCompressionEncryptionPb* internal_default_instance() {
    return reinterpret_cast<const GetCompressionEncryptionPb*>(
               &_GetCompressionEncryptionPb_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;

  friend void swap(GetCompressionEncryptionPb& a, GetCompressionEncryptionPb& b) {
    a.Swap(&b);
  }
  inline void Swap(GetCompressionEncryptionPb* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline GetCompressionEncryptionPb* New() const final {
    return CreateMaybeMessage<GetCompressionEncryptionPb>(nullptr);
  }

  GetCompressionEncryptionPb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<GetCompressionEncryptionPb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const GetCompressionEncryptionPb& from);
  void MergeFrom(const GetCompressionEncryptionPb& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(GetCompressionEncryptionPb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.GetCompressionEncryptionPb";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_FlashCommandsPb_2eproto);
    return ::descriptor_table_FlashCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kFlashSessionFieldNumber = 1,
    kBlockFieldNumber = 2,
  };
  // .OpenTestSystem.OtxDiagManager.Common.DFlashSessionPb FlashSession = 1;
  bool has_flashsession() const;
  private:
  bool _internal_has_flashsession() const;
  public:
  void clear_flashsession();
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& flashsession() const;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* release_flashsession();
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* mutable_flashsession();
  void set_allocated_flashsession(::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& _internal_flashsession() const;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* _internal_mutable_flashsession();
  public:

  // double Block = 2;
  void clear_block();
  double block() const;
  void set_block(double value);
  private:
  double _internal_block() const;
  void _internal_set_block(double value);
  public:

  // @@protoc_insertion_point(class_scope:OpenTestSystem.OtxDiagManager.Common.GetCompressionEncryptionPb)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession_;
  double block_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_FlashCommandsPb_2eproto;
};
// -------------------------------------------------------------------

class GetNumberOfSecuritiesPb :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:OpenTestSystem.OtxDiagManager.Common.GetNumberOfSecuritiesPb) */ {
 public:
  GetNumberOfSecuritiesPb();
  virtual ~GetNumberOfSecuritiesPb();

  GetNumberOfSecuritiesPb(const GetNumberOfSecuritiesPb& from);
  GetNumberOfSecuritiesPb(GetNumberOfSecuritiesPb&& from) noexcept
    : GetNumberOfSecuritiesPb() {
    *this = ::std::move(from);
  }

  inline GetNumberOfSecuritiesPb& operator=(const GetNumberOfSecuritiesPb& from) {
    CopyFrom(from);
    return *this;
  }
  inline GetNumberOfSecuritiesPb& operator=(GetNumberOfSecuritiesPb&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const GetNumberOfSecuritiesPb& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const GetNumberOfSecuritiesPb* internal_default_instance() {
    return reinterpret_cast<const GetNumberOfSecuritiesPb*>(
               &_GetNumberOfSecuritiesPb_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;

  friend void swap(GetNumberOfSecuritiesPb& a, GetNumberOfSecuritiesPb& b) {
    a.Swap(&b);
  }
  inline void Swap(GetNumberOfSecuritiesPb* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline GetNumberOfSecuritiesPb* New() const final {
    return CreateMaybeMessage<GetNumberOfSecuritiesPb>(nullptr);
  }

  GetNumberOfSecuritiesPb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<GetNumberOfSecuritiesPb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const GetNumberOfSecuritiesPb& from);
  void MergeFrom(const GetNumberOfSecuritiesPb& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(GetNumberOfSecuritiesPb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.GetNumberOfSecuritiesPb";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_FlashCommandsPb_2eproto);
    return ::descriptor_table_FlashCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kFlashSessionFieldNumber = 1,
    kBlockFieldNumber = 2,
  };
  // .OpenTestSystem.OtxDiagManager.Common.DFlashSessionPb FlashSession = 1;
  bool has_flashsession() const;
  private:
  bool _internal_has_flashsession() const;
  public:
  void clear_flashsession();
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& flashsession() const;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* release_flashsession();
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* mutable_flashsession();
  void set_allocated_flashsession(::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& _internal_flashsession() const;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* _internal_mutable_flashsession();
  public:

  // .OpenTestSystem.OtxDiagManager.Common.DBlockCollectionPb Block = 2;
  bool has_block() const;
  private:
  bool _internal_has_block() const;
  public:
  void clear_block();
  const ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb& block() const;
  ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb* release_block();
  ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb* mutable_block();
  void set_allocated_block(::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb* block);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb& _internal_block() const;
  ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb* _internal_mutable_block();
  public:

  // @@protoc_insertion_point(class_scope:OpenTestSystem.OtxDiagManager.Common.GetNumberOfSecuritiesPb)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession_;
  ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb* block_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_FlashCommandsPb_2eproto;
};
// -------------------------------------------------------------------

class GetTypePb :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:OpenTestSystem.OtxDiagManager.Common.GetTypePb) */ {
 public:
  GetTypePb();
  virtual ~GetTypePb();

  GetTypePb(const GetTypePb& from);
  GetTypePb(GetTypePb&& from) noexcept
    : GetTypePb() {
    *this = ::std::move(from);
  }

  inline GetTypePb& operator=(const GetTypePb& from) {
    CopyFrom(from);
    return *this;
  }
  inline GetTypePb& operator=(GetTypePb&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const GetTypePb& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const GetTypePb* internal_default_instance() {
    return reinterpret_cast<const GetTypePb*>(
               &_GetTypePb_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;

  friend void swap(GetTypePb& a, GetTypePb& b) {
    a.Swap(&b);
  }
  inline void Swap(GetTypePb* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline GetTypePb* New() const final {
    return CreateMaybeMessage<GetTypePb>(nullptr);
  }

  GetTypePb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<GetTypePb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const GetTypePb& from);
  void MergeFrom(const GetTypePb& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(GetTypePb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.GetTypePb";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_FlashCommandsPb_2eproto);
    return ::descriptor_table_FlashCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kFlashSessionFieldNumber = 1,
    kBlockFieldNumber = 2,
  };
  // .OpenTestSystem.OtxDiagManager.Common.DFlashSessionPb FlashSession = 1;
  bool has_flashsession() const;
  private:
  bool _internal_has_flashsession() const;
  public:
  void clear_flashsession();
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& flashsession() const;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* release_flashsession();
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* mutable_flashsession();
  void set_allocated_flashsession(::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& _internal_flashsession() const;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* _internal_mutable_flashsession();
  public:

  // double Block = 2;
  void clear_block();
  double block() const;
  void set_block(double value);
  private:
  double _internal_block() const;
  void _internal_set_block(double value);
  public:

  // @@protoc_insertion_point(class_scope:OpenTestSystem.OtxDiagManager.Common.GetTypePb)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession_;
  double block_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_FlashCommandsPb_2eproto;
};
// -------------------------------------------------------------------

class GetStartAddressPb :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:OpenTestSystem.OtxDiagManager.Common.GetStartAddressPb) */ {
 public:
  GetStartAddressPb();
  virtual ~GetStartAddressPb();

  GetStartAddressPb(const GetStartAddressPb& from);
  GetStartAddressPb(GetStartAddressPb&& from) noexcept
    : GetStartAddressPb() {
    *this = ::std::move(from);
  }

  inline GetStartAddressPb& operator=(const GetStartAddressPb& from) {
    CopyFrom(from);
    return *this;
  }
  inline GetStartAddressPb& operator=(GetStartAddressPb&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const GetStartAddressPb& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const GetStartAddressPb* internal_default_instance() {
    return reinterpret_cast<const GetStartAddressPb*>(
               &_GetStartAddressPb_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    10;

  friend void swap(GetStartAddressPb& a, GetStartAddressPb& b) {
    a.Swap(&b);
  }
  inline void Swap(GetStartAddressPb* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline GetStartAddressPb* New() const final {
    return CreateMaybeMessage<GetStartAddressPb>(nullptr);
  }

  GetStartAddressPb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<GetStartAddressPb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const GetStartAddressPb& from);
  void MergeFrom(const GetStartAddressPb& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(GetStartAddressPb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.GetStartAddressPb";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_FlashCommandsPb_2eproto);
    return ::descriptor_table_FlashCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kFlashSessionFieldNumber = 1,
    kBlockFieldNumber = 2,
    kSegmentFieldNumber = 3,
  };
  // .OpenTestSystem.OtxDiagManager.Common.DFlashSessionPb FlashSession = 1;
  bool has_flashsession() const;
  private:
  bool _internal_has_flashsession() const;
  public:
  void clear_flashsession();
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& flashsession() const;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* release_flashsession();
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* mutable_flashsession();
  void set_allocated_flashsession(::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& _internal_flashsession() const;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* _internal_mutable_flashsession();
  public:

  // double Block = 2;
  void clear_block();
  double block() const;
  void set_block(double value);
  private:
  double _internal_block() const;
  void _internal_set_block(double value);
  public:

  // double Segment = 3;
  void clear_segment();
  double segment() const;
  void set_segment(double value);
  private:
  double _internal_segment() const;
  void _internal_set_segment(double value);
  public:

  // @@protoc_insertion_point(class_scope:OpenTestSystem.OtxDiagManager.Common.GetStartAddressPb)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession_;
  double block_;
  double segment_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_FlashCommandsPb_2eproto;
};
// -------------------------------------------------------------------

class GetCompressedSizePb :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:OpenTestSystem.OtxDiagManager.Common.GetCompressedSizePb) */ {
 public:
  GetCompressedSizePb();
  virtual ~GetCompressedSizePb();

  GetCompressedSizePb(const GetCompressedSizePb& from);
  GetCompressedSizePb(GetCompressedSizePb&& from) noexcept
    : GetCompressedSizePb() {
    *this = ::std::move(from);
  }

  inline GetCompressedSizePb& operator=(const GetCompressedSizePb& from) {
    CopyFrom(from);
    return *this;
  }
  inline GetCompressedSizePb& operator=(GetCompressedSizePb&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const GetCompressedSizePb& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const GetCompressedSizePb* internal_default_instance() {
    return reinterpret_cast<const GetCompressedSizePb*>(
               &_GetCompressedSizePb_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    11;

  friend void swap(GetCompressedSizePb& a, GetCompressedSizePb& b) {
    a.Swap(&b);
  }
  inline void Swap(GetCompressedSizePb* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline GetCompressedSizePb* New() const final {
    return CreateMaybeMessage<GetCompressedSizePb>(nullptr);
  }

  GetCompressedSizePb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<GetCompressedSizePb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const GetCompressedSizePb& from);
  void MergeFrom(const GetCompressedSizePb& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(GetCompressedSizePb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.GetCompressedSizePb";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_FlashCommandsPb_2eproto);
    return ::descriptor_table_FlashCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kFlashSessionFieldNumber = 1,
    kBlockFieldNumber = 2,
    kSegmentFieldNumber = 3,
  };
  // .OpenTestSystem.OtxDiagManager.Common.DFlashSessionPb FlashSession = 1;
  bool has_flashsession() const;
  private:
  bool _internal_has_flashsession() const;
  public:
  void clear_flashsession();
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& flashsession() const;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* release_flashsession();
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* mutable_flashsession();
  void set_allocated_flashsession(::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& _internal_flashsession() const;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* _internal_mutable_flashsession();
  public:

  // double Block = 2;
  void clear_block();
  double block() const;
  void set_block(double value);
  private:
  double _internal_block() const;
  void _internal_set_block(double value);
  public:

  // double Segment = 3;
  void clear_segment();
  double segment() const;
  void set_segment(double value);
  private:
  double _internal_segment() const;
  void _internal_set_segment(double value);
  public:

  // @@protoc_insertion_point(class_scope:OpenTestSystem.OtxDiagManager.Common.GetCompressedSizePb)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession_;
  double block_;
  double segment_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_FlashCommandsPb_2eproto;
};
// -------------------------------------------------------------------

class GetUncompressedSizePb :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:OpenTestSystem.OtxDiagManager.Common.GetUncompressedSizePb) */ {
 public:
  GetUncompressedSizePb();
  virtual ~GetUncompressedSizePb();

  GetUncompressedSizePb(const GetUncompressedSizePb& from);
  GetUncompressedSizePb(GetUncompressedSizePb&& from) noexcept
    : GetUncompressedSizePb() {
    *this = ::std::move(from);
  }

  inline GetUncompressedSizePb& operator=(const GetUncompressedSizePb& from) {
    CopyFrom(from);
    return *this;
  }
  inline GetUncompressedSizePb& operator=(GetUncompressedSizePb&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const GetUncompressedSizePb& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const GetUncompressedSizePb* internal_default_instance() {
    return reinterpret_cast<const GetUncompressedSizePb*>(
               &_GetUncompressedSizePb_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    12;

  friend void swap(GetUncompressedSizePb& a, GetUncompressedSizePb& b) {
    a.Swap(&b);
  }
  inline void Swap(GetUncompressedSizePb* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline GetUncompressedSizePb* New() const final {
    return CreateMaybeMessage<GetUncompressedSizePb>(nullptr);
  }

  GetUncompressedSizePb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<GetUncompressedSizePb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const GetUncompressedSizePb& from);
  void MergeFrom(const GetUncompressedSizePb& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(GetUncompressedSizePb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.GetUncompressedSizePb";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_FlashCommandsPb_2eproto);
    return ::descriptor_table_FlashCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kFlashSessionFieldNumber = 1,
    kBlockFieldNumber = 2,
    kSegmentFieldNumber = 3,
  };
  // .OpenTestSystem.OtxDiagManager.Common.DFlashSessionPb FlashSession = 1;
  bool has_flashsession() const;
  private:
  bool _internal_has_flashsession() const;
  public:
  void clear_flashsession();
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& flashsession() const;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* release_flashsession();
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* mutable_flashsession();
  void set_allocated_flashsession(::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& _internal_flashsession() const;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* _internal_mutable_flashsession();
  public:

  // double Block = 2;
  void clear_block();
  double block() const;
  void set_block(double value);
  private:
  double _internal_block() const;
  void _internal_set_block(double value);
  public:

  // double Segment = 3;
  void clear_segment();
  double segment() const;
  void set_segment(double value);
  private:
  double _internal_segment() const;
  void _internal_set_segment(double value);
  public:

  // @@protoc_insertion_point(class_scope:OpenTestSystem.OtxDiagManager.Common.GetUncompressedSizePb)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession_;
  double block_;
  double segment_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_FlashCommandsPb_2eproto;
};
// -------------------------------------------------------------------

class GetSignaturePb :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:OpenTestSystem.OtxDiagManager.Common.GetSignaturePb) */ {
 public:
  GetSignaturePb();
  virtual ~GetSignaturePb();

  GetSignaturePb(const GetSignaturePb& from);
  GetSignaturePb(GetSignaturePb&& from) noexcept
    : GetSignaturePb() {
    *this = ::std::move(from);
  }

  inline GetSignaturePb& operator=(const GetSignaturePb& from) {
    CopyFrom(from);
    return *this;
  }
  inline GetSignaturePb& operator=(GetSignaturePb&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const GetSignaturePb& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const GetSignaturePb* internal_default_instance() {
    return reinterpret_cast<const GetSignaturePb*>(
               &_GetSignaturePb_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    13;

  friend void swap(GetSignaturePb& a, GetSignaturePb& b) {
    a.Swap(&b);
  }
  inline void Swap(GetSignaturePb* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline GetSignaturePb* New() const final {
    return CreateMaybeMessage<GetSignaturePb>(nullptr);
  }

  GetSignaturePb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<GetSignaturePb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const GetSignaturePb& from);
  void MergeFrom(const GetSignaturePb& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(GetSignaturePb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.GetSignaturePb";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_FlashCommandsPb_2eproto);
    return ::descriptor_table_FlashCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kFlashSessionFieldNumber = 1,
    kBlockFieldNumber = 2,
    kSecurityFieldNumber = 3,
  };
  // .OpenTestSystem.OtxDiagManager.Common.DFlashSessionPb FlashSession = 1;
  bool has_flashsession() const;
  private:
  bool _internal_has_flashsession() const;
  public:
  void clear_flashsession();
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& flashsession() const;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* release_flashsession();
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* mutable_flashsession();
  void set_allocated_flashsession(::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& _internal_flashsession() const;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* _internal_mutable_flashsession();
  public:

  // .OpenTestSystem.OtxDiagManager.Common.DBlockCollectionPb Block = 2;
  bool has_block() const;
  private:
  bool _internal_has_block() const;
  public:
  void clear_block();
  const ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb& block() const;
  ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb* release_block();
  ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb* mutable_block();
  void set_allocated_block(::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb* block);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb& _internal_block() const;
  ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb* _internal_mutable_block();
  public:

  // double Security = 3;
  void clear_security();
  double security() const;
  void set_security(double value);
  private:
  double _internal_security() const;
  void _internal_set_security(double value);
  public:

  // @@protoc_insertion_point(class_scope:OpenTestSystem.OtxDiagManager.Common.GetSignaturePb)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession_;
  ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb* block_;
  double security_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_FlashCommandsPb_2eproto;
};
// -------------------------------------------------------------------

class GetValidityPb :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:OpenTestSystem.OtxDiagManager.Common.GetValidityPb) */ {
 public:
  GetValidityPb();
  virtual ~GetValidityPb();

  GetValidityPb(const GetValidityPb& from);
  GetValidityPb(GetValidityPb&& from) noexcept
    : GetValidityPb() {
    *this = ::std::move(from);
  }

  inline GetValidityPb& operator=(const GetValidityPb& from) {
    CopyFrom(from);
    return *this;
  }
  inline GetValidityPb& operator=(GetValidityPb&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const GetValidityPb& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const GetValidityPb* internal_default_instance() {
    return reinterpret_cast<const GetValidityPb*>(
               &_GetValidityPb_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    14;

  friend void swap(GetValidityPb& a, GetValidityPb& b) {
    a.Swap(&b);
  }
  inline void Swap(GetValidityPb* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline GetValidityPb* New() const final {
    return CreateMaybeMessage<GetValidityPb>(nullptr);
  }

  GetValidityPb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<GetValidityPb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const GetValidityPb& from);
  void MergeFrom(const GetValidityPb& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(GetValidityPb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.GetValidityPb";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_FlashCommandsPb_2eproto);
    return ::descriptor_table_FlashCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kFlashSessionFieldNumber = 1,
    kBlockFieldNumber = 2,
    kSecurityFieldNumber = 3,
  };
  // .OpenTestSystem.OtxDiagManager.Common.DFlashSessionPb FlashSession = 1;
  bool has_flashsession() const;
  private:
  bool _internal_has_flashsession() const;
  public:
  void clear_flashsession();
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& flashsession() const;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* release_flashsession();
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* mutable_flashsession();
  void set_allocated_flashsession(::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& _internal_flashsession() const;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* _internal_mutable_flashsession();
  public:

  // .OpenTestSystem.OtxDiagManager.Common.DBlockCollectionPb Block = 2;
  bool has_block() const;
  private:
  bool _internal_has_block() const;
  public:
  void clear_block();
  const ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb& block() const;
  ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb* release_block();
  ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb* mutable_block();
  void set_allocated_block(::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb* block);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb& _internal_block() const;
  ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb* _internal_mutable_block();
  public:

  // double Security = 3;
  void clear_security();
  double security() const;
  void set_security(double value);
  private:
  double _internal_security() const;
  void _internal_set_security(double value);
  public:

  // @@protoc_insertion_point(class_scope:OpenTestSystem.OtxDiagManager.Common.GetValidityPb)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession_;
  ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb* block_;
  double security_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_FlashCommandsPb_2eproto;
};
// -------------------------------------------------------------------

class GetChecksumPb :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:OpenTestSystem.OtxDiagManager.Common.GetChecksumPb) */ {
 public:
  GetChecksumPb();
  virtual ~GetChecksumPb();

  GetChecksumPb(const GetChecksumPb& from);
  GetChecksumPb(GetChecksumPb&& from) noexcept
    : GetChecksumPb() {
    *this = ::std::move(from);
  }

  inline GetChecksumPb& operator=(const GetChecksumPb& from) {
    CopyFrom(from);
    return *this;
  }
  inline GetChecksumPb& operator=(GetChecksumPb&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const GetChecksumPb& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const GetChecksumPb* internal_default_instance() {
    return reinterpret_cast<const GetChecksumPb*>(
               &_GetChecksumPb_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    15;

  friend void swap(GetChecksumPb& a, GetChecksumPb& b) {
    a.Swap(&b);
  }
  inline void Swap(GetChecksumPb* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline GetChecksumPb* New() const final {
    return CreateMaybeMessage<GetChecksumPb>(nullptr);
  }

  GetChecksumPb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<GetChecksumPb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const GetChecksumPb& from);
  void MergeFrom(const GetChecksumPb& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(GetChecksumPb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.GetChecksumPb";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_FlashCommandsPb_2eproto);
    return ::descriptor_table_FlashCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kFlashSessionFieldNumber = 1,
    kBlockFieldNumber = 2,
    kSecurityFieldNumber = 3,
  };
  // .OpenTestSystem.OtxDiagManager.Common.DFlashSessionPb FlashSession = 1;
  bool has_flashsession() const;
  private:
  bool _internal_has_flashsession() const;
  public:
  void clear_flashsession();
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& flashsession() const;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* release_flashsession();
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* mutable_flashsession();
  void set_allocated_flashsession(::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& _internal_flashsession() const;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* _internal_mutable_flashsession();
  public:

  // .OpenTestSystem.OtxDiagManager.Common.DBlockCollectionPb Block = 2;
  bool has_block() const;
  private:
  bool _internal_has_block() const;
  public:
  void clear_block();
  const ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb& block() const;
  ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb* release_block();
  ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb* mutable_block();
  void set_allocated_block(::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb* block);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb& _internal_block() const;
  ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb* _internal_mutable_block();
  public:

  // double Security = 3;
  void clear_security();
  double security() const;
  void set_security(double value);
  private:
  double _internal_security() const;
  void _internal_set_security(double value);
  public:

  // @@protoc_insertion_point(class_scope:OpenTestSystem.OtxDiagManager.Common.GetChecksumPb)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession_;
  ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb* block_;
  double security_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_FlashCommandsPb_2eproto;
};
// -------------------------------------------------------------------

class GetSecurityMethodPb :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:OpenTestSystem.OtxDiagManager.Common.GetSecurityMethodPb) */ {
 public:
  GetSecurityMethodPb();
  virtual ~GetSecurityMethodPb();

  GetSecurityMethodPb(const GetSecurityMethodPb& from);
  GetSecurityMethodPb(GetSecurityMethodPb&& from) noexcept
    : GetSecurityMethodPb() {
    *this = ::std::move(from);
  }

  inline GetSecurityMethodPb& operator=(const GetSecurityMethodPb& from) {
    CopyFrom(from);
    return *this;
  }
  inline GetSecurityMethodPb& operator=(GetSecurityMethodPb&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const GetSecurityMethodPb& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const GetSecurityMethodPb* internal_default_instance() {
    return reinterpret_cast<const GetSecurityMethodPb*>(
               &_GetSecurityMethodPb_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    16;

  friend void swap(GetSecurityMethodPb& a, GetSecurityMethodPb& b) {
    a.Swap(&b);
  }
  inline void Swap(GetSecurityMethodPb* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline GetSecurityMethodPb* New() const final {
    return CreateMaybeMessage<GetSecurityMethodPb>(nullptr);
  }

  GetSecurityMethodPb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<GetSecurityMethodPb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const GetSecurityMethodPb& from);
  void MergeFrom(const GetSecurityMethodPb& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(GetSecurityMethodPb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.GetSecurityMethodPb";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_FlashCommandsPb_2eproto);
    return ::descriptor_table_FlashCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kFlashSessionFieldNumber = 1,
    kBlockFieldNumber = 2,
    kSecurityFieldNumber = 3,
  };
  // .OpenTestSystem.OtxDiagManager.Common.DFlashSessionPb FlashSession = 1;
  bool has_flashsession() const;
  private:
  bool _internal_has_flashsession() const;
  public:
  void clear_flashsession();
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& flashsession() const;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* release_flashsession();
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* mutable_flashsession();
  void set_allocated_flashsession(::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& _internal_flashsession() const;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* _internal_mutable_flashsession();
  public:

  // .OpenTestSystem.OtxDiagManager.Common.DBlockCollectionPb Block = 2;
  bool has_block() const;
  private:
  bool _internal_has_block() const;
  public:
  void clear_block();
  const ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb& block() const;
  ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb* release_block();
  ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb* mutable_block();
  void set_allocated_block(::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb* block);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb& _internal_block() const;
  ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb* _internal_mutable_block();
  public:

  // double Security = 3;
  void clear_security();
  double security() const;
  void set_security(double value);
  private:
  double _internal_security() const;
  void _internal_set_security(double value);
  public:

  // @@protoc_insertion_point(class_scope:OpenTestSystem.OtxDiagManager.Common.GetSecurityMethodPb)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession_;
  ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb* block_;
  double security_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_FlashCommandsPb_2eproto;
};
// -------------------------------------------------------------------

class GetOwnIdentFromEcuPb :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:OpenTestSystem.OtxDiagManager.Common.GetOwnIdentFromEcuPb) */ {
 public:
  GetOwnIdentFromEcuPb();
  virtual ~GetOwnIdentFromEcuPb();

  GetOwnIdentFromEcuPb(const GetOwnIdentFromEcuPb& from);
  GetOwnIdentFromEcuPb(GetOwnIdentFromEcuPb&& from) noexcept
    : GetOwnIdentFromEcuPb() {
    *this = ::std::move(from);
  }

  inline GetOwnIdentFromEcuPb& operator=(const GetOwnIdentFromEcuPb& from) {
    CopyFrom(from);
    return *this;
  }
  inline GetOwnIdentFromEcuPb& operator=(GetOwnIdentFromEcuPb&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const GetOwnIdentFromEcuPb& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const GetOwnIdentFromEcuPb* internal_default_instance() {
    return reinterpret_cast<const GetOwnIdentFromEcuPb*>(
               &_GetOwnIdentFromEcuPb_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    17;

  friend void swap(GetOwnIdentFromEcuPb& a, GetOwnIdentFromEcuPb& b) {
    a.Swap(&b);
  }
  inline void Swap(GetOwnIdentFromEcuPb* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline GetOwnIdentFromEcuPb* New() const final {
    return CreateMaybeMessage<GetOwnIdentFromEcuPb>(nullptr);
  }

  GetOwnIdentFromEcuPb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<GetOwnIdentFromEcuPb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const GetOwnIdentFromEcuPb& from);
  void MergeFrom(const GetOwnIdentFromEcuPb& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(GetOwnIdentFromEcuPb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.GetOwnIdentFromEcuPb";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_FlashCommandsPb_2eproto);
    return ::descriptor_table_FlashCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kFlashSessionFieldNumber = 1,
    kBlockFieldNumber = 2,
    kNumberFieldNumber = 3,
  };
  // .OpenTestSystem.OtxDiagManager.Common.DFlashSessionPb FlashSession = 1;
  bool has_flashsession() const;
  private:
  bool _internal_has_flashsession() const;
  public:
  void clear_flashsession();
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& flashsession() const;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* release_flashsession();
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* mutable_flashsession();
  void set_allocated_flashsession(::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& _internal_flashsession() const;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* _internal_mutable_flashsession();
  public:

  // double Block = 2;
  void clear_block();
  double block() const;
  void set_block(double value);
  private:
  double _internal_block() const;
  void _internal_set_block(double value);
  public:

  // double Number = 3;
  void clear_number();
  double number() const;
  void set_number(double value);
  private:
  double _internal_number() const;
  void _internal_set_number(double value);
  public:

  // @@protoc_insertion_point(class_scope:OpenTestSystem.OtxDiagManager.Common.GetOwnIdentFromEcuPb)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession_;
  double block_;
  double number_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_FlashCommandsPb_2eproto;
};
// -------------------------------------------------------------------

class GetOwnIdentPb :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:OpenTestSystem.OtxDiagManager.Common.GetOwnIdentPb) */ {
 public:
  GetOwnIdentPb();
  virtual ~GetOwnIdentPb();

  GetOwnIdentPb(const GetOwnIdentPb& from);
  GetOwnIdentPb(GetOwnIdentPb&& from) noexcept
    : GetOwnIdentPb() {
    *this = ::std::move(from);
  }

  inline GetOwnIdentPb& operator=(const GetOwnIdentPb& from) {
    CopyFrom(from);
    return *this;
  }
  inline GetOwnIdentPb& operator=(GetOwnIdentPb&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const GetOwnIdentPb& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const GetOwnIdentPb* internal_default_instance() {
    return reinterpret_cast<const GetOwnIdentPb*>(
               &_GetOwnIdentPb_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    18;

  friend void swap(GetOwnIdentPb& a, GetOwnIdentPb& b) {
    a.Swap(&b);
  }
  inline void Swap(GetOwnIdentPb* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline GetOwnIdentPb* New() const final {
    return CreateMaybeMessage<GetOwnIdentPb>(nullptr);
  }

  GetOwnIdentPb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<GetOwnIdentPb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const GetOwnIdentPb& from);
  void MergeFrom(const GetOwnIdentPb& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(GetOwnIdentPb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.GetOwnIdentPb";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_FlashCommandsPb_2eproto);
    return ::descriptor_table_FlashCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kFlashSessionFieldNumber = 1,
    kBlockFieldNumber = 2,
    kNumberFieldNumber = 3,
  };
  // .OpenTestSystem.OtxDiagManager.Common.DFlashSessionPb FlashSession = 1;
  bool has_flashsession() const;
  private:
  bool _internal_has_flashsession() const;
  public:
  void clear_flashsession();
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& flashsession() const;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* release_flashsession();
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* mutable_flashsession();
  void set_allocated_flashsession(::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& _internal_flashsession() const;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* _internal_mutable_flashsession();
  public:

  // double Block = 2;
  void clear_block();
  double block() const;
  void set_block(double value);
  private:
  double _internal_block() const;
  void _internal_set_block(double value);
  public:

  // double Number = 3;
  void clear_number();
  double number() const;
  void set_number(double value);
  private:
  double _internal_number() const;
  void _internal_set_number(double value);
  public:

  // @@protoc_insertion_point(class_scope:OpenTestSystem.OtxDiagManager.Common.GetOwnIdentPb)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession_;
  double block_;
  double number_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_FlashCommandsPb_2eproto;
};
// -------------------------------------------------------------------

class GetDownloadDataPb :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:OpenTestSystem.OtxDiagManager.Common.GetDownloadDataPb) */ {
 public:
  GetDownloadDataPb();
  virtual ~GetDownloadDataPb();

  GetDownloadDataPb(const GetDownloadDataPb& from);
  GetDownloadDataPb(GetDownloadDataPb&& from) noexcept
    : GetDownloadDataPb() {
    *this = ::std::move(from);
  }

  inline GetDownloadDataPb& operator=(const GetDownloadDataPb& from) {
    CopyFrom(from);
    return *this;
  }
  inline GetDownloadDataPb& operator=(GetDownloadDataPb&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const GetDownloadDataPb& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const GetDownloadDataPb* internal_default_instance() {
    return reinterpret_cast<const GetDownloadDataPb*>(
               &_GetDownloadDataPb_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    19;

  friend void swap(GetDownloadDataPb& a, GetDownloadDataPb& b) {
    a.Swap(&b);
  }
  inline void Swap(GetDownloadDataPb* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline GetDownloadDataPb* New() const final {
    return CreateMaybeMessage<GetDownloadDataPb>(nullptr);
  }

  GetDownloadDataPb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<GetDownloadDataPb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const GetDownloadDataPb& from);
  void MergeFrom(const GetDownloadDataPb& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(GetDownloadDataPb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.GetDownloadDataPb";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_FlashCommandsPb_2eproto);
    return ::descriptor_table_FlashCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kDataFieldNumber = 6,
    kFlashSessionFieldNumber = 1,
    kBlockFieldNumber = 2,
    kSegmentFieldNumber = 3,
    kSizeFieldNumber = 4,
    kPositionFieldNumber = 5,
  };
  // bytes Data = 6;
  void clear_data();
  const std::string& data() const;
  void set_data(const std::string& value);
  void set_data(std::string&& value);
  void set_data(const char* value);
  void set_data(const void* value, size_t size);
  std::string* mutable_data();
  std::string* release_data();
  void set_allocated_data(std::string* data);
  private:
  const std::string& _internal_data() const;
  void _internal_set_data(const std::string& value);
  std::string* _internal_mutable_data();
  public:

  // .OpenTestSystem.OtxDiagManager.Common.DFlashSessionPb FlashSession = 1;
  bool has_flashsession() const;
  private:
  bool _internal_has_flashsession() const;
  public:
  void clear_flashsession();
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& flashsession() const;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* release_flashsession();
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* mutable_flashsession();
  void set_allocated_flashsession(::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& _internal_flashsession() const;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* _internal_mutable_flashsession();
  public:

  // double Block = 2;
  void clear_block();
  double block() const;
  void set_block(double value);
  private:
  double _internal_block() const;
  void _internal_set_block(double value);
  public:

  // double Segment = 3;
  void clear_segment();
  double segment() const;
  void set_segment(double value);
  private:
  double _internal_segment() const;
  void _internal_set_segment(double value);
  public:

  // double Size = 4;
  void clear_size();
  double size() const;
  void set_size(double value);
  private:
  double _internal_size() const;
  void _internal_set_size(double value);
  public:

  // double Position = 5;
  void clear_position();
  double position() const;
  void set_position(double value);
  private:
  double _internal_position() const;
  void _internal_set_position(double value);
  public:

  // @@protoc_insertion_point(class_scope:OpenTestSystem.OtxDiagManager.Common.GetDownloadDataPb)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr data_;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession_;
  double block_;
  double segment_;
  double size_;
  double position_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_FlashCommandsPb_2eproto;
};
// -------------------------------------------------------------------

class CreateFlashJobPb :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:OpenTestSystem.OtxDiagManager.Common.CreateFlashJobPb) */ {
 public:
  CreateFlashJobPb();
  virtual ~CreateFlashJobPb();

  CreateFlashJobPb(const CreateFlashJobPb& from);
  CreateFlashJobPb(CreateFlashJobPb&& from) noexcept
    : CreateFlashJobPb() {
    *this = ::std::move(from);
  }

  inline CreateFlashJobPb& operator=(const CreateFlashJobPb& from) {
    CopyFrom(from);
    return *this;
  }
  inline CreateFlashJobPb& operator=(CreateFlashJobPb&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const CreateFlashJobPb& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const CreateFlashJobPb* internal_default_instance() {
    return reinterpret_cast<const CreateFlashJobPb*>(
               &_CreateFlashJobPb_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    20;

  friend void swap(CreateFlashJobPb& a, CreateFlashJobPb& b) {
    a.Swap(&b);
  }
  inline void Swap(CreateFlashJobPb* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline CreateFlashJobPb* New() const final {
    return CreateMaybeMessage<CreateFlashJobPb>(nullptr);
  }

  CreateFlashJobPb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CreateFlashJobPb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CreateFlashJobPb& from);
  void MergeFrom(const CreateFlashJobPb& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CreateFlashJobPb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.CreateFlashJobPb";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_FlashCommandsPb_2eproto);
    return ::descriptor_table_FlashCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kComChannelFieldNumber = 1,
    kFlashSessionFieldNumber = 2,
  };
  // .OpenTestSystem.OtxDiagManager.Common.DComChannelPb ComChannel = 1;
  bool has_comchannel() const;
  private:
  bool _internal_has_comchannel() const;
  public:
  void clear_comchannel();
  const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& comchannel() const;
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* release_comchannel();
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* mutable_comchannel();
  void set_allocated_comchannel(::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* comchannel);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& _internal_comchannel() const;
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* _internal_mutable_comchannel();
  public:

  // .OpenTestSystem.OtxDiagManager.Common.DFlashSessionPb FlashSession = 2;
  bool has_flashsession() const;
  private:
  bool _internal_has_flashsession() const;
  public:
  void clear_flashsession();
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& flashsession() const;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* release_flashsession();
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* mutable_flashsession();
  void set_allocated_flashsession(::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& _internal_flashsession() const;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* _internal_mutable_flashsession();
  public:

  // @@protoc_insertion_point(class_scope:OpenTestSystem.OtxDiagManager.Common.CreateFlashJobPb)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* comchannel_;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_FlashCommandsPb_2eproto;
};
// -------------------------------------------------------------------

class CreateFlashJobByNamePb :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:OpenTestSystem.OtxDiagManager.Common.CreateFlashJobByNamePb) */ {
 public:
  CreateFlashJobByNamePb();
  virtual ~CreateFlashJobByNamePb();

  CreateFlashJobByNamePb(const CreateFlashJobByNamePb& from);
  CreateFlashJobByNamePb(CreateFlashJobByNamePb&& from) noexcept
    : CreateFlashJobByNamePb() {
    *this = ::std::move(from);
  }

  inline CreateFlashJobByNamePb& operator=(const CreateFlashJobByNamePb& from) {
    CopyFrom(from);
    return *this;
  }
  inline CreateFlashJobByNamePb& operator=(CreateFlashJobByNamePb&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const CreateFlashJobByNamePb& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const CreateFlashJobByNamePb* internal_default_instance() {
    return reinterpret_cast<const CreateFlashJobByNamePb*>(
               &_CreateFlashJobByNamePb_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    21;

  friend void swap(CreateFlashJobByNamePb& a, CreateFlashJobByNamePb& b) {
    a.Swap(&b);
  }
  inline void Swap(CreateFlashJobByNamePb* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline CreateFlashJobByNamePb* New() const final {
    return CreateMaybeMessage<CreateFlashJobByNamePb>(nullptr);
  }

  CreateFlashJobByNamePb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CreateFlashJobByNamePb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CreateFlashJobByNamePb& from);
  void MergeFrom(const CreateFlashJobByNamePb& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CreateFlashJobByNamePb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.CreateFlashJobByNamePb";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_FlashCommandsPb_2eproto);
    return ::descriptor_table_FlashCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kNameFieldNumber = 2,
    kComChannelFieldNumber = 1,
    kFlashSessionFieldNumber = 3,
  };
  // string Name = 2;
  void clear_name();
  const std::string& name() const;
  void set_name(const std::string& value);
  void set_name(std::string&& value);
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  std::string* mutable_name();
  std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // .OpenTestSystem.OtxDiagManager.Common.DComChannelPb ComChannel = 1;
  bool has_comchannel() const;
  private:
  bool _internal_has_comchannel() const;
  public:
  void clear_comchannel();
  const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& comchannel() const;
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* release_comchannel();
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* mutable_comchannel();
  void set_allocated_comchannel(::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* comchannel);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& _internal_comchannel() const;
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* _internal_mutable_comchannel();
  public:

  // .OpenTestSystem.OtxDiagManager.Common.DFlashSessionPb FlashSession = 3;
  bool has_flashsession() const;
  private:
  bool _internal_has_flashsession() const;
  public:
  void clear_flashsession();
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& flashsession() const;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* release_flashsession();
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* mutable_flashsession();
  void set_allocated_flashsession(::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& _internal_flashsession() const;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* _internal_mutable_flashsession();
  public:

  // @@protoc_insertion_point(class_scope:OpenTestSystem.OtxDiagManager.Common.CreateFlashJobByNamePb)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* comchannel_;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_FlashCommandsPb_2eproto;
};
// -------------------------------------------------------------------

class CreateFlashJobBySemanticPb :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:OpenTestSystem.OtxDiagManager.Common.CreateFlashJobBySemanticPb) */ {
 public:
  CreateFlashJobBySemanticPb();
  virtual ~CreateFlashJobBySemanticPb();

  CreateFlashJobBySemanticPb(const CreateFlashJobBySemanticPb& from);
  CreateFlashJobBySemanticPb(CreateFlashJobBySemanticPb&& from) noexcept
    : CreateFlashJobBySemanticPb() {
    *this = ::std::move(from);
  }

  inline CreateFlashJobBySemanticPb& operator=(const CreateFlashJobBySemanticPb& from) {
    CopyFrom(from);
    return *this;
  }
  inline CreateFlashJobBySemanticPb& operator=(CreateFlashJobBySemanticPb&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const CreateFlashJobBySemanticPb& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const CreateFlashJobBySemanticPb* internal_default_instance() {
    return reinterpret_cast<const CreateFlashJobBySemanticPb*>(
               &_CreateFlashJobBySemanticPb_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    22;

  friend void swap(CreateFlashJobBySemanticPb& a, CreateFlashJobBySemanticPb& b) {
    a.Swap(&b);
  }
  inline void Swap(CreateFlashJobBySemanticPb* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline CreateFlashJobBySemanticPb* New() const final {
    return CreateMaybeMessage<CreateFlashJobBySemanticPb>(nullptr);
  }

  CreateFlashJobBySemanticPb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CreateFlashJobBySemanticPb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CreateFlashJobBySemanticPb& from);
  void MergeFrom(const CreateFlashJobBySemanticPb& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CreateFlashJobBySemanticPb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.CreateFlashJobBySemanticPb";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_FlashCommandsPb_2eproto);
    return ::descriptor_table_FlashCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kSemanticFieldNumber = 2,
    kComChannelFieldNumber = 1,
    kFlashSessionFieldNumber = 3,
  };
  // string Semantic = 2;
  void clear_semantic();
  const std::string& semantic() const;
  void set_semantic(const std::string& value);
  void set_semantic(std::string&& value);
  void set_semantic(const char* value);
  void set_semantic(const char* value, size_t size);
  std::string* mutable_semantic();
  std::string* release_semantic();
  void set_allocated_semantic(std::string* semantic);
  private:
  const std::string& _internal_semantic() const;
  void _internal_set_semantic(const std::string& value);
  std::string* _internal_mutable_semantic();
  public:

  // .OpenTestSystem.OtxDiagManager.Common.DComChannelPb ComChannel = 1;
  bool has_comchannel() const;
  private:
  bool _internal_has_comchannel() const;
  public:
  void clear_comchannel();
  const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& comchannel() const;
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* release_comchannel();
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* mutable_comchannel();
  void set_allocated_comchannel(::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* comchannel);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& _internal_comchannel() const;
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* _internal_mutable_comchannel();
  public:

  // .OpenTestSystem.OtxDiagManager.Common.DFlashSessionPb FlashSession = 3;
  bool has_flashsession() const;
  private:
  bool _internal_has_flashsession() const;
  public:
  void clear_flashsession();
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& flashsession() const;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* release_flashsession();
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* mutable_flashsession();
  void set_allocated_flashsession(::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& _internal_flashsession() const;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* _internal_mutable_flashsession();
  public:

  // @@protoc_insertion_point(class_scope:OpenTestSystem.OtxDiagManager.Common.CreateFlashJobBySemanticPb)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr semantic_;
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* comchannel_;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_FlashCommandsPb_2eproto;
};
// -------------------------------------------------------------------

class SetFlashSessionPb :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:OpenTestSystem.OtxDiagManager.Common.SetFlashSessionPb) */ {
 public:
  SetFlashSessionPb();
  virtual ~SetFlashSessionPb();

  SetFlashSessionPb(const SetFlashSessionPb& from);
  SetFlashSessionPb(SetFlashSessionPb&& from) noexcept
    : SetFlashSessionPb() {
    *this = ::std::move(from);
  }

  inline SetFlashSessionPb& operator=(const SetFlashSessionPb& from) {
    CopyFrom(from);
    return *this;
  }
  inline SetFlashSessionPb& operator=(SetFlashSessionPb&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const SetFlashSessionPb& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const SetFlashSessionPb* internal_default_instance() {
    return reinterpret_cast<const SetFlashSessionPb*>(
               &_SetFlashSessionPb_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    23;

  friend void swap(SetFlashSessionPb& a, SetFlashSessionPb& b) {
    a.Swap(&b);
  }
  inline void Swap(SetFlashSessionPb* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline SetFlashSessionPb* New() const final {
    return CreateMaybeMessage<SetFlashSessionPb>(nullptr);
  }

  SetFlashSessionPb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<SetFlashSessionPb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const SetFlashSessionPb& from);
  void MergeFrom(const SetFlashSessionPb& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SetFlashSessionPb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.SetFlashSessionPb";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_FlashCommandsPb_2eproto);
    return ::descriptor_table_FlashCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kFlashJobFieldNumber = 1,
    kFlashSessionFieldNumber = 2,
  };
  // .OpenTestSystem.OtxDiagManager.Common.DFlashJobPb FlashJob = 1;
  bool has_flashjob() const;
  private:
  bool _internal_has_flashjob() const;
  public:
  void clear_flashjob();
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashJobPb& flashjob() const;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashJobPb* release_flashjob();
  ::OpenTestSystem::OtxDiagManager::Common::DFlashJobPb* mutable_flashjob();
  void set_allocated_flashjob(::OpenTestSystem::OtxDiagManager::Common::DFlashJobPb* flashjob);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashJobPb& _internal_flashjob() const;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashJobPb* _internal_mutable_flashjob();
  public:

  // .OpenTestSystem.OtxDiagManager.Common.DFlashSessionPb FlashSession = 2;
  bool has_flashsession() const;
  private:
  bool _internal_has_flashsession() const;
  public:
  void clear_flashsession();
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& flashsession() const;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* release_flashsession();
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* mutable_flashsession();
  void set_allocated_flashsession(::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& _internal_flashsession() const;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* _internal_mutable_flashsession();
  public:

  // @@protoc_insertion_point(class_scope:OpenTestSystem.OtxDiagManager.Common.SetFlashSessionPb)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashJobPb* flashjob_;
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_FlashCommandsPb_2eproto;
};
// ===================================================================


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

#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// GetListOfValidFlashSessionsPb

// .OpenTestSystem.OtxDiagManager.Common.DComChannelPb ComChannel = 1;
inline bool GetListOfValidFlashSessionsPb::_internal_has_comchannel() const {
  return this != internal_default_instance() && comchannel_ != nullptr;
}
inline bool GetListOfValidFlashSessionsPb::has_comchannel() const {
  return _internal_has_comchannel();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& GetListOfValidFlashSessionsPb::_internal_comchannel() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* p = comchannel_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DComChannelPb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& GetListOfValidFlashSessionsPb::comchannel() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetListOfValidFlashSessionsPb.ComChannel)
  return _internal_comchannel();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* GetListOfValidFlashSessionsPb::release_comchannel() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetListOfValidFlashSessionsPb.ComChannel)
  
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* temp = comchannel_;
  comchannel_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* GetListOfValidFlashSessionsPb::_internal_mutable_comchannel() {
  
  if (comchannel_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DComChannelPb>(GetArenaNoVirtual());
    comchannel_ = p;
  }
  return comchannel_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* GetListOfValidFlashSessionsPb::mutable_comchannel() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetListOfValidFlashSessionsPb.ComChannel)
  return _internal_mutable_comchannel();
}
inline void GetListOfValidFlashSessionsPb::set_allocated_comchannel(::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* comchannel) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(comchannel_);
  }
  if (comchannel) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      comchannel = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, comchannel, submessage_arena);
    }
    
  } else {
    
  }
  comchannel_ = comchannel;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.GetListOfValidFlashSessionsPb.ComChannel)
}

// .OpenTestSystem.OtxDiagManager.Common.DAudiencesPb Audience = 2;
inline void GetListOfValidFlashSessionsPb::clear_audience() {
  audience_ = 0;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DAudiencesPb GetListOfValidFlashSessionsPb::_internal_audience() const {
  return static_cast< ::OpenTestSystem::OtxDiagManager::Common::DAudiencesPb >(audience_);
}
inline ::OpenTestSystem::OtxDiagManager::Common::DAudiencesPb GetListOfValidFlashSessionsPb::audience() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetListOfValidFlashSessionsPb.Audience)
  return _internal_audience();
}
inline void GetListOfValidFlashSessionsPb::_internal_set_audience(::OpenTestSystem::OtxDiagManager::Common::DAudiencesPb value) {
  
  audience_ = value;
}
inline void GetListOfValidFlashSessionsPb::set_audience(::OpenTestSystem::OtxDiagManager::Common::DAudiencesPb value) {
  _internal_set_audience(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.GetListOfValidFlashSessionsPb.Audience)
}

// .OpenTestSystem.OtxDiagManager.Common.DDirectionsPb Direction = 3;
inline void GetListOfValidFlashSessionsPb::clear_direction() {
  direction_ = 0;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DDirectionsPb GetListOfValidFlashSessionsPb::_internal_direction() const {
  return static_cast< ::OpenTestSystem::OtxDiagManager::Common::DDirectionsPb >(direction_);
}
inline ::OpenTestSystem::OtxDiagManager::Common::DDirectionsPb GetListOfValidFlashSessionsPb::direction() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetListOfValidFlashSessionsPb.Direction)
  return _internal_direction();
}
inline void GetListOfValidFlashSessionsPb::_internal_set_direction(::OpenTestSystem::OtxDiagManager::Common::DDirectionsPb value) {
  
  direction_ = value;
}
inline void GetListOfValidFlashSessionsPb::set_direction(::OpenTestSystem::OtxDiagManager::Common::DDirectionsPb value) {
  _internal_set_direction(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.GetListOfValidFlashSessionsPb.Direction)
}

// -------------------------------------------------------------------

// GetFlashSessionPb

// string SessionId = 1;
inline void GetFlashSessionPb::clear_sessionid() {
  sessionid_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& GetFlashSessionPb::sessionid() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetFlashSessionPb.SessionId)
  return _internal_sessionid();
}
inline void GetFlashSessionPb::set_sessionid(const std::string& value) {
  _internal_set_sessionid(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.GetFlashSessionPb.SessionId)
}
inline std::string* GetFlashSessionPb::mutable_sessionid() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetFlashSessionPb.SessionId)
  return _internal_mutable_sessionid();
}
inline const std::string& GetFlashSessionPb::_internal_sessionid() const {
  return sessionid_.GetNoArena();
}
inline void GetFlashSessionPb::_internal_set_sessionid(const std::string& value) {
  
  sessionid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void GetFlashSessionPb::set_sessionid(std::string&& value) {
  
  sessionid_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.GetFlashSessionPb.SessionId)
}
inline void GetFlashSessionPb::set_sessionid(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  sessionid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.GetFlashSessionPb.SessionId)
}
inline void GetFlashSessionPb::set_sessionid(const char* value, size_t size) {
  
  sessionid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.GetFlashSessionPb.SessionId)
}
inline std::string* GetFlashSessionPb::_internal_mutable_sessionid() {
  
  return sessionid_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* GetFlashSessionPb::release_sessionid() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetFlashSessionPb.SessionId)
  
  return sessionid_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void GetFlashSessionPb::set_allocated_sessionid(std::string* sessionid) {
  if (sessionid != nullptr) {
    
  } else {
    
  }
  sessionid_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), sessionid);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.GetFlashSessionPb.SessionId)
}

// -------------------------------------------------------------------

// GetNumberOfBlocksPb

// .OpenTestSystem.OtxDiagManager.Common.DFlashSessionPb FlashSession = 1;
inline bool GetNumberOfBlocksPb::_internal_has_flashsession() const {
  return this != internal_default_instance() && flashsession_ != nullptr;
}
inline bool GetNumberOfBlocksPb::has_flashsession() const {
  return _internal_has_flashsession();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& GetNumberOfBlocksPb::_internal_flashsession() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* p = flashsession_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DFlashSessionPb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& GetNumberOfBlocksPb::flashsession() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetNumberOfBlocksPb.FlashSession)
  return _internal_flashsession();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* GetNumberOfBlocksPb::release_flashsession() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetNumberOfBlocksPb.FlashSession)
  
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* temp = flashsession_;
  flashsession_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* GetNumberOfBlocksPb::_internal_mutable_flashsession() {
  
  if (flashsession_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb>(GetArenaNoVirtual());
    flashsession_ = p;
  }
  return flashsession_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* GetNumberOfBlocksPb::mutable_flashsession() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetNumberOfBlocksPb.FlashSession)
  return _internal_mutable_flashsession();
}
inline void GetNumberOfBlocksPb::set_allocated_flashsession(::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(flashsession_);
  }
  if (flashsession) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      flashsession = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, flashsession, submessage_arena);
    }
    
  } else {
    
  }
  flashsession_ = flashsession;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.GetNumberOfBlocksPb.FlashSession)
}

// -------------------------------------------------------------------

// GetNumberOfSegmentsPb

// .OpenTestSystem.OtxDiagManager.Common.DFlashSessionPb FlashSession = 1;
inline bool GetNumberOfSegmentsPb::_internal_has_flashsession() const {
  return this != internal_default_instance() && flashsession_ != nullptr;
}
inline bool GetNumberOfSegmentsPb::has_flashsession() const {
  return _internal_has_flashsession();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& GetNumberOfSegmentsPb::_internal_flashsession() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* p = flashsession_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DFlashSessionPb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& GetNumberOfSegmentsPb::flashsession() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetNumberOfSegmentsPb.FlashSession)
  return _internal_flashsession();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* GetNumberOfSegmentsPb::release_flashsession() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetNumberOfSegmentsPb.FlashSession)
  
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* temp = flashsession_;
  flashsession_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* GetNumberOfSegmentsPb::_internal_mutable_flashsession() {
  
  if (flashsession_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb>(GetArenaNoVirtual());
    flashsession_ = p;
  }
  return flashsession_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* GetNumberOfSegmentsPb::mutable_flashsession() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetNumberOfSegmentsPb.FlashSession)
  return _internal_mutable_flashsession();
}
inline void GetNumberOfSegmentsPb::set_allocated_flashsession(::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(flashsession_);
  }
  if (flashsession) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      flashsession = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, flashsession, submessage_arena);
    }
    
  } else {
    
  }
  flashsession_ = flashsession;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.GetNumberOfSegmentsPb.FlashSession)
}

// double Block = 2;
inline void GetNumberOfSegmentsPb::clear_block() {
  block_ = 0;
}
inline double GetNumberOfSegmentsPb::_internal_block() const {
  return block_;
}
inline double GetNumberOfSegmentsPb::block() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetNumberOfSegmentsPb.Block)
  return _internal_block();
}
inline void GetNumberOfSegmentsPb::_internal_set_block(double value) {
  
  block_ = value;
}
inline void GetNumberOfSegmentsPb::set_block(double value) {
  _internal_set_block(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.GetNumberOfSegmentsPb.Block)
}

// -------------------------------------------------------------------

// GetLogicalBlockIDPb

// .OpenTestSystem.OtxDiagManager.Common.DFlashSessionPb FlashSession = 1;
inline bool GetLogicalBlockIDPb::_internal_has_flashsession() const {
  return this != internal_default_instance() && flashsession_ != nullptr;
}
inline bool GetLogicalBlockIDPb::has_flashsession() const {
  return _internal_has_flashsession();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& GetLogicalBlockIDPb::_internal_flashsession() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* p = flashsession_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DFlashSessionPb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& GetLogicalBlockIDPb::flashsession() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetLogicalBlockIDPb.FlashSession)
  return _internal_flashsession();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* GetLogicalBlockIDPb::release_flashsession() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetLogicalBlockIDPb.FlashSession)
  
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* temp = flashsession_;
  flashsession_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* GetLogicalBlockIDPb::_internal_mutable_flashsession() {
  
  if (flashsession_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb>(GetArenaNoVirtual());
    flashsession_ = p;
  }
  return flashsession_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* GetLogicalBlockIDPb::mutable_flashsession() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetLogicalBlockIDPb.FlashSession)
  return _internal_mutable_flashsession();
}
inline void GetLogicalBlockIDPb::set_allocated_flashsession(::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(flashsession_);
  }
  if (flashsession) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      flashsession = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, flashsession, submessage_arena);
    }
    
  } else {
    
  }
  flashsession_ = flashsession;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.GetLogicalBlockIDPb.FlashSession)
}

// double Block = 2;
inline void GetLogicalBlockIDPb::clear_block() {
  block_ = 0;
}
inline double GetLogicalBlockIDPb::_internal_block() const {
  return block_;
}
inline double GetLogicalBlockIDPb::block() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetLogicalBlockIDPb.Block)
  return _internal_block();
}
inline void GetLogicalBlockIDPb::_internal_set_block(double value) {
  
  block_ = value;
}
inline void GetLogicalBlockIDPb::set_block(double value) {
  _internal_set_block(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.GetLogicalBlockIDPb.Block)
}

// -------------------------------------------------------------------

// BlockIsValidForAudiencePb

// .OpenTestSystem.OtxDiagManager.Common.DFlashSessionPb FlashSession = 1;
inline bool BlockIsValidForAudiencePb::_internal_has_flashsession() const {
  return this != internal_default_instance() && flashsession_ != nullptr;
}
inline bool BlockIsValidForAudiencePb::has_flashsession() const {
  return _internal_has_flashsession();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& BlockIsValidForAudiencePb::_internal_flashsession() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* p = flashsession_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DFlashSessionPb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& BlockIsValidForAudiencePb::flashsession() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.BlockIsValidForAudiencePb.FlashSession)
  return _internal_flashsession();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* BlockIsValidForAudiencePb::release_flashsession() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.BlockIsValidForAudiencePb.FlashSession)
  
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* temp = flashsession_;
  flashsession_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* BlockIsValidForAudiencePb::_internal_mutable_flashsession() {
  
  if (flashsession_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb>(GetArenaNoVirtual());
    flashsession_ = p;
  }
  return flashsession_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* BlockIsValidForAudiencePb::mutable_flashsession() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.BlockIsValidForAudiencePb.FlashSession)
  return _internal_mutable_flashsession();
}
inline void BlockIsValidForAudiencePb::set_allocated_flashsession(::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(flashsession_);
  }
  if (flashsession) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      flashsession = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, flashsession, submessage_arena);
    }
    
  } else {
    
  }
  flashsession_ = flashsession;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.BlockIsValidForAudiencePb.FlashSession)
}

// double Block = 2;
inline void BlockIsValidForAudiencePb::clear_block() {
  block_ = 0;
}
inline double BlockIsValidForAudiencePb::_internal_block() const {
  return block_;
}
inline double BlockIsValidForAudiencePb::block() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.BlockIsValidForAudiencePb.Block)
  return _internal_block();
}
inline void BlockIsValidForAudiencePb::_internal_set_block(double value) {
  
  block_ = value;
}
inline void BlockIsValidForAudiencePb::set_block(double value) {
  _internal_set_block(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.BlockIsValidForAudiencePb.Block)
}

// .OpenTestSystem.OtxDiagManager.Common.DAudiencesPb Audience = 3;
inline void BlockIsValidForAudiencePb::clear_audience() {
  audience_ = 0;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DAudiencesPb BlockIsValidForAudiencePb::_internal_audience() const {
  return static_cast< ::OpenTestSystem::OtxDiagManager::Common::DAudiencesPb >(audience_);
}
inline ::OpenTestSystem::OtxDiagManager::Common::DAudiencesPb BlockIsValidForAudiencePb::audience() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.BlockIsValidForAudiencePb.Audience)
  return _internal_audience();
}
inline void BlockIsValidForAudiencePb::_internal_set_audience(::OpenTestSystem::OtxDiagManager::Common::DAudiencesPb value) {
  
  audience_ = value;
}
inline void BlockIsValidForAudiencePb::set_audience(::OpenTestSystem::OtxDiagManager::Common::DAudiencesPb value) {
  _internal_set_audience(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.BlockIsValidForAudiencePb.Audience)
}

// -------------------------------------------------------------------

// GetNumberOfOwnIdentsPb

// .OpenTestSystem.OtxDiagManager.Common.DFlashSessionPb FlashSession = 1;
inline bool GetNumberOfOwnIdentsPb::_internal_has_flashsession() const {
  return this != internal_default_instance() && flashsession_ != nullptr;
}
inline bool GetNumberOfOwnIdentsPb::has_flashsession() const {
  return _internal_has_flashsession();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& GetNumberOfOwnIdentsPb::_internal_flashsession() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* p = flashsession_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DFlashSessionPb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& GetNumberOfOwnIdentsPb::flashsession() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetNumberOfOwnIdentsPb.FlashSession)
  return _internal_flashsession();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* GetNumberOfOwnIdentsPb::release_flashsession() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetNumberOfOwnIdentsPb.FlashSession)
  
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* temp = flashsession_;
  flashsession_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* GetNumberOfOwnIdentsPb::_internal_mutable_flashsession() {
  
  if (flashsession_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb>(GetArenaNoVirtual());
    flashsession_ = p;
  }
  return flashsession_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* GetNumberOfOwnIdentsPb::mutable_flashsession() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetNumberOfOwnIdentsPb.FlashSession)
  return _internal_mutable_flashsession();
}
inline void GetNumberOfOwnIdentsPb::set_allocated_flashsession(::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(flashsession_);
  }
  if (flashsession) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      flashsession = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, flashsession, submessage_arena);
    }
    
  } else {
    
  }
  flashsession_ = flashsession;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.GetNumberOfOwnIdentsPb.FlashSession)
}

// double Block = 2;
inline void GetNumberOfOwnIdentsPb::clear_block() {
  block_ = 0;
}
inline double GetNumberOfOwnIdentsPb::_internal_block() const {
  return block_;
}
inline double GetNumberOfOwnIdentsPb::block() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetNumberOfOwnIdentsPb.Block)
  return _internal_block();
}
inline void GetNumberOfOwnIdentsPb::_internal_set_block(double value) {
  
  block_ = value;
}
inline void GetNumberOfOwnIdentsPb::set_block(double value) {
  _internal_set_block(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.GetNumberOfOwnIdentsPb.Block)
}

// -------------------------------------------------------------------

// GetCompressionEncryptionPb

// .OpenTestSystem.OtxDiagManager.Common.DFlashSessionPb FlashSession = 1;
inline bool GetCompressionEncryptionPb::_internal_has_flashsession() const {
  return this != internal_default_instance() && flashsession_ != nullptr;
}
inline bool GetCompressionEncryptionPb::has_flashsession() const {
  return _internal_has_flashsession();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& GetCompressionEncryptionPb::_internal_flashsession() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* p = flashsession_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DFlashSessionPb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& GetCompressionEncryptionPb::flashsession() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetCompressionEncryptionPb.FlashSession)
  return _internal_flashsession();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* GetCompressionEncryptionPb::release_flashsession() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetCompressionEncryptionPb.FlashSession)
  
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* temp = flashsession_;
  flashsession_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* GetCompressionEncryptionPb::_internal_mutable_flashsession() {
  
  if (flashsession_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb>(GetArenaNoVirtual());
    flashsession_ = p;
  }
  return flashsession_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* GetCompressionEncryptionPb::mutable_flashsession() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetCompressionEncryptionPb.FlashSession)
  return _internal_mutable_flashsession();
}
inline void GetCompressionEncryptionPb::set_allocated_flashsession(::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(flashsession_);
  }
  if (flashsession) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      flashsession = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, flashsession, submessage_arena);
    }
    
  } else {
    
  }
  flashsession_ = flashsession;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.GetCompressionEncryptionPb.FlashSession)
}

// double Block = 2;
inline void GetCompressionEncryptionPb::clear_block() {
  block_ = 0;
}
inline double GetCompressionEncryptionPb::_internal_block() const {
  return block_;
}
inline double GetCompressionEncryptionPb::block() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetCompressionEncryptionPb.Block)
  return _internal_block();
}
inline void GetCompressionEncryptionPb::_internal_set_block(double value) {
  
  block_ = value;
}
inline void GetCompressionEncryptionPb::set_block(double value) {
  _internal_set_block(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.GetCompressionEncryptionPb.Block)
}

// -------------------------------------------------------------------

// GetNumberOfSecuritiesPb

// .OpenTestSystem.OtxDiagManager.Common.DFlashSessionPb FlashSession = 1;
inline bool GetNumberOfSecuritiesPb::_internal_has_flashsession() const {
  return this != internal_default_instance() && flashsession_ != nullptr;
}
inline bool GetNumberOfSecuritiesPb::has_flashsession() const {
  return _internal_has_flashsession();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& GetNumberOfSecuritiesPb::_internal_flashsession() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* p = flashsession_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DFlashSessionPb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& GetNumberOfSecuritiesPb::flashsession() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetNumberOfSecuritiesPb.FlashSession)
  return _internal_flashsession();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* GetNumberOfSecuritiesPb::release_flashsession() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetNumberOfSecuritiesPb.FlashSession)
  
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* temp = flashsession_;
  flashsession_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* GetNumberOfSecuritiesPb::_internal_mutable_flashsession() {
  
  if (flashsession_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb>(GetArenaNoVirtual());
    flashsession_ = p;
  }
  return flashsession_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* GetNumberOfSecuritiesPb::mutable_flashsession() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetNumberOfSecuritiesPb.FlashSession)
  return _internal_mutable_flashsession();
}
inline void GetNumberOfSecuritiesPb::set_allocated_flashsession(::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(flashsession_);
  }
  if (flashsession) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      flashsession = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, flashsession, submessage_arena);
    }
    
  } else {
    
  }
  flashsession_ = flashsession;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.GetNumberOfSecuritiesPb.FlashSession)
}

// .OpenTestSystem.OtxDiagManager.Common.DBlockCollectionPb Block = 2;
inline bool GetNumberOfSecuritiesPb::_internal_has_block() const {
  return this != internal_default_instance() && block_ != nullptr;
}
inline bool GetNumberOfSecuritiesPb::has_block() const {
  return _internal_has_block();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb& GetNumberOfSecuritiesPb::_internal_block() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb* p = block_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DBlockCollectionPb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb& GetNumberOfSecuritiesPb::block() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetNumberOfSecuritiesPb.Block)
  return _internal_block();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb* GetNumberOfSecuritiesPb::release_block() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetNumberOfSecuritiesPb.Block)
  
  ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb* temp = block_;
  block_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb* GetNumberOfSecuritiesPb::_internal_mutable_block() {
  
  if (block_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb>(GetArenaNoVirtual());
    block_ = p;
  }
  return block_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb* GetNumberOfSecuritiesPb::mutable_block() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetNumberOfSecuritiesPb.Block)
  return _internal_mutable_block();
}
inline void GetNumberOfSecuritiesPb::set_allocated_block(::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb* block) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(block_);
  }
  if (block) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      block = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, block, submessage_arena);
    }
    
  } else {
    
  }
  block_ = block;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.GetNumberOfSecuritiesPb.Block)
}

// -------------------------------------------------------------------

// GetTypePb

// .OpenTestSystem.OtxDiagManager.Common.DFlashSessionPb FlashSession = 1;
inline bool GetTypePb::_internal_has_flashsession() const {
  return this != internal_default_instance() && flashsession_ != nullptr;
}
inline bool GetTypePb::has_flashsession() const {
  return _internal_has_flashsession();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& GetTypePb::_internal_flashsession() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* p = flashsession_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DFlashSessionPb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& GetTypePb::flashsession() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetTypePb.FlashSession)
  return _internal_flashsession();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* GetTypePb::release_flashsession() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetTypePb.FlashSession)
  
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* temp = flashsession_;
  flashsession_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* GetTypePb::_internal_mutable_flashsession() {
  
  if (flashsession_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb>(GetArenaNoVirtual());
    flashsession_ = p;
  }
  return flashsession_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* GetTypePb::mutable_flashsession() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetTypePb.FlashSession)
  return _internal_mutable_flashsession();
}
inline void GetTypePb::set_allocated_flashsession(::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(flashsession_);
  }
  if (flashsession) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      flashsession = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, flashsession, submessage_arena);
    }
    
  } else {
    
  }
  flashsession_ = flashsession;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.GetTypePb.FlashSession)
}

// double Block = 2;
inline void GetTypePb::clear_block() {
  block_ = 0;
}
inline double GetTypePb::_internal_block() const {
  return block_;
}
inline double GetTypePb::block() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetTypePb.Block)
  return _internal_block();
}
inline void GetTypePb::_internal_set_block(double value) {
  
  block_ = value;
}
inline void GetTypePb::set_block(double value) {
  _internal_set_block(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.GetTypePb.Block)
}

// -------------------------------------------------------------------

// GetStartAddressPb

// .OpenTestSystem.OtxDiagManager.Common.DFlashSessionPb FlashSession = 1;
inline bool GetStartAddressPb::_internal_has_flashsession() const {
  return this != internal_default_instance() && flashsession_ != nullptr;
}
inline bool GetStartAddressPb::has_flashsession() const {
  return _internal_has_flashsession();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& GetStartAddressPb::_internal_flashsession() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* p = flashsession_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DFlashSessionPb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& GetStartAddressPb::flashsession() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetStartAddressPb.FlashSession)
  return _internal_flashsession();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* GetStartAddressPb::release_flashsession() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetStartAddressPb.FlashSession)
  
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* temp = flashsession_;
  flashsession_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* GetStartAddressPb::_internal_mutable_flashsession() {
  
  if (flashsession_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb>(GetArenaNoVirtual());
    flashsession_ = p;
  }
  return flashsession_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* GetStartAddressPb::mutable_flashsession() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetStartAddressPb.FlashSession)
  return _internal_mutable_flashsession();
}
inline void GetStartAddressPb::set_allocated_flashsession(::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(flashsession_);
  }
  if (flashsession) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      flashsession = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, flashsession, submessage_arena);
    }
    
  } else {
    
  }
  flashsession_ = flashsession;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.GetStartAddressPb.FlashSession)
}

// double Block = 2;
inline void GetStartAddressPb::clear_block() {
  block_ = 0;
}
inline double GetStartAddressPb::_internal_block() const {
  return block_;
}
inline double GetStartAddressPb::block() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetStartAddressPb.Block)
  return _internal_block();
}
inline void GetStartAddressPb::_internal_set_block(double value) {
  
  block_ = value;
}
inline void GetStartAddressPb::set_block(double value) {
  _internal_set_block(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.GetStartAddressPb.Block)
}

// double Segment = 3;
inline void GetStartAddressPb::clear_segment() {
  segment_ = 0;
}
inline double GetStartAddressPb::_internal_segment() const {
  return segment_;
}
inline double GetStartAddressPb::segment() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetStartAddressPb.Segment)
  return _internal_segment();
}
inline void GetStartAddressPb::_internal_set_segment(double value) {
  
  segment_ = value;
}
inline void GetStartAddressPb::set_segment(double value) {
  _internal_set_segment(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.GetStartAddressPb.Segment)
}

// -------------------------------------------------------------------

// GetCompressedSizePb

// .OpenTestSystem.OtxDiagManager.Common.DFlashSessionPb FlashSession = 1;
inline bool GetCompressedSizePb::_internal_has_flashsession() const {
  return this != internal_default_instance() && flashsession_ != nullptr;
}
inline bool GetCompressedSizePb::has_flashsession() const {
  return _internal_has_flashsession();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& GetCompressedSizePb::_internal_flashsession() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* p = flashsession_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DFlashSessionPb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& GetCompressedSizePb::flashsession() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetCompressedSizePb.FlashSession)
  return _internal_flashsession();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* GetCompressedSizePb::release_flashsession() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetCompressedSizePb.FlashSession)
  
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* temp = flashsession_;
  flashsession_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* GetCompressedSizePb::_internal_mutable_flashsession() {
  
  if (flashsession_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb>(GetArenaNoVirtual());
    flashsession_ = p;
  }
  return flashsession_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* GetCompressedSizePb::mutable_flashsession() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetCompressedSizePb.FlashSession)
  return _internal_mutable_flashsession();
}
inline void GetCompressedSizePb::set_allocated_flashsession(::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(flashsession_);
  }
  if (flashsession) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      flashsession = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, flashsession, submessage_arena);
    }
    
  } else {
    
  }
  flashsession_ = flashsession;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.GetCompressedSizePb.FlashSession)
}

// double Block = 2;
inline void GetCompressedSizePb::clear_block() {
  block_ = 0;
}
inline double GetCompressedSizePb::_internal_block() const {
  return block_;
}
inline double GetCompressedSizePb::block() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetCompressedSizePb.Block)
  return _internal_block();
}
inline void GetCompressedSizePb::_internal_set_block(double value) {
  
  block_ = value;
}
inline void GetCompressedSizePb::set_block(double value) {
  _internal_set_block(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.GetCompressedSizePb.Block)
}

// double Segment = 3;
inline void GetCompressedSizePb::clear_segment() {
  segment_ = 0;
}
inline double GetCompressedSizePb::_internal_segment() const {
  return segment_;
}
inline double GetCompressedSizePb::segment() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetCompressedSizePb.Segment)
  return _internal_segment();
}
inline void GetCompressedSizePb::_internal_set_segment(double value) {
  
  segment_ = value;
}
inline void GetCompressedSizePb::set_segment(double value) {
  _internal_set_segment(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.GetCompressedSizePb.Segment)
}

// -------------------------------------------------------------------

// GetUncompressedSizePb

// .OpenTestSystem.OtxDiagManager.Common.DFlashSessionPb FlashSession = 1;
inline bool GetUncompressedSizePb::_internal_has_flashsession() const {
  return this != internal_default_instance() && flashsession_ != nullptr;
}
inline bool GetUncompressedSizePb::has_flashsession() const {
  return _internal_has_flashsession();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& GetUncompressedSizePb::_internal_flashsession() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* p = flashsession_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DFlashSessionPb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& GetUncompressedSizePb::flashsession() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetUncompressedSizePb.FlashSession)
  return _internal_flashsession();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* GetUncompressedSizePb::release_flashsession() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetUncompressedSizePb.FlashSession)
  
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* temp = flashsession_;
  flashsession_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* GetUncompressedSizePb::_internal_mutable_flashsession() {
  
  if (flashsession_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb>(GetArenaNoVirtual());
    flashsession_ = p;
  }
  return flashsession_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* GetUncompressedSizePb::mutable_flashsession() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetUncompressedSizePb.FlashSession)
  return _internal_mutable_flashsession();
}
inline void GetUncompressedSizePb::set_allocated_flashsession(::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(flashsession_);
  }
  if (flashsession) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      flashsession = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, flashsession, submessage_arena);
    }
    
  } else {
    
  }
  flashsession_ = flashsession;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.GetUncompressedSizePb.FlashSession)
}

// double Block = 2;
inline void GetUncompressedSizePb::clear_block() {
  block_ = 0;
}
inline double GetUncompressedSizePb::_internal_block() const {
  return block_;
}
inline double GetUncompressedSizePb::block() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetUncompressedSizePb.Block)
  return _internal_block();
}
inline void GetUncompressedSizePb::_internal_set_block(double value) {
  
  block_ = value;
}
inline void GetUncompressedSizePb::set_block(double value) {
  _internal_set_block(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.GetUncompressedSizePb.Block)
}

// double Segment = 3;
inline void GetUncompressedSizePb::clear_segment() {
  segment_ = 0;
}
inline double GetUncompressedSizePb::_internal_segment() const {
  return segment_;
}
inline double GetUncompressedSizePb::segment() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetUncompressedSizePb.Segment)
  return _internal_segment();
}
inline void GetUncompressedSizePb::_internal_set_segment(double value) {
  
  segment_ = value;
}
inline void GetUncompressedSizePb::set_segment(double value) {
  _internal_set_segment(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.GetUncompressedSizePb.Segment)
}

// -------------------------------------------------------------------

// GetSignaturePb

// .OpenTestSystem.OtxDiagManager.Common.DFlashSessionPb FlashSession = 1;
inline bool GetSignaturePb::_internal_has_flashsession() const {
  return this != internal_default_instance() && flashsession_ != nullptr;
}
inline bool GetSignaturePb::has_flashsession() const {
  return _internal_has_flashsession();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& GetSignaturePb::_internal_flashsession() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* p = flashsession_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DFlashSessionPb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& GetSignaturePb::flashsession() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetSignaturePb.FlashSession)
  return _internal_flashsession();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* GetSignaturePb::release_flashsession() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetSignaturePb.FlashSession)
  
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* temp = flashsession_;
  flashsession_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* GetSignaturePb::_internal_mutable_flashsession() {
  
  if (flashsession_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb>(GetArenaNoVirtual());
    flashsession_ = p;
  }
  return flashsession_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* GetSignaturePb::mutable_flashsession() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetSignaturePb.FlashSession)
  return _internal_mutable_flashsession();
}
inline void GetSignaturePb::set_allocated_flashsession(::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(flashsession_);
  }
  if (flashsession) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      flashsession = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, flashsession, submessage_arena);
    }
    
  } else {
    
  }
  flashsession_ = flashsession;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.GetSignaturePb.FlashSession)
}

// .OpenTestSystem.OtxDiagManager.Common.DBlockCollectionPb Block = 2;
inline bool GetSignaturePb::_internal_has_block() const {
  return this != internal_default_instance() && block_ != nullptr;
}
inline bool GetSignaturePb::has_block() const {
  return _internal_has_block();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb& GetSignaturePb::_internal_block() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb* p = block_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DBlockCollectionPb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb& GetSignaturePb::block() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetSignaturePb.Block)
  return _internal_block();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb* GetSignaturePb::release_block() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetSignaturePb.Block)
  
  ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb* temp = block_;
  block_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb* GetSignaturePb::_internal_mutable_block() {
  
  if (block_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb>(GetArenaNoVirtual());
    block_ = p;
  }
  return block_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb* GetSignaturePb::mutable_block() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetSignaturePb.Block)
  return _internal_mutable_block();
}
inline void GetSignaturePb::set_allocated_block(::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb* block) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(block_);
  }
  if (block) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      block = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, block, submessage_arena);
    }
    
  } else {
    
  }
  block_ = block;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.GetSignaturePb.Block)
}

// double Security = 3;
inline void GetSignaturePb::clear_security() {
  security_ = 0;
}
inline double GetSignaturePb::_internal_security() const {
  return security_;
}
inline double GetSignaturePb::security() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetSignaturePb.Security)
  return _internal_security();
}
inline void GetSignaturePb::_internal_set_security(double value) {
  
  security_ = value;
}
inline void GetSignaturePb::set_security(double value) {
  _internal_set_security(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.GetSignaturePb.Security)
}

// -------------------------------------------------------------------

// GetValidityPb

// .OpenTestSystem.OtxDiagManager.Common.DFlashSessionPb FlashSession = 1;
inline bool GetValidityPb::_internal_has_flashsession() const {
  return this != internal_default_instance() && flashsession_ != nullptr;
}
inline bool GetValidityPb::has_flashsession() const {
  return _internal_has_flashsession();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& GetValidityPb::_internal_flashsession() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* p = flashsession_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DFlashSessionPb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& GetValidityPb::flashsession() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetValidityPb.FlashSession)
  return _internal_flashsession();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* GetValidityPb::release_flashsession() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetValidityPb.FlashSession)
  
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* temp = flashsession_;
  flashsession_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* GetValidityPb::_internal_mutable_flashsession() {
  
  if (flashsession_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb>(GetArenaNoVirtual());
    flashsession_ = p;
  }
  return flashsession_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* GetValidityPb::mutable_flashsession() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetValidityPb.FlashSession)
  return _internal_mutable_flashsession();
}
inline void GetValidityPb::set_allocated_flashsession(::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(flashsession_);
  }
  if (flashsession) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      flashsession = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, flashsession, submessage_arena);
    }
    
  } else {
    
  }
  flashsession_ = flashsession;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.GetValidityPb.FlashSession)
}

// .OpenTestSystem.OtxDiagManager.Common.DBlockCollectionPb Block = 2;
inline bool GetValidityPb::_internal_has_block() const {
  return this != internal_default_instance() && block_ != nullptr;
}
inline bool GetValidityPb::has_block() const {
  return _internal_has_block();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb& GetValidityPb::_internal_block() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb* p = block_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DBlockCollectionPb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb& GetValidityPb::block() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetValidityPb.Block)
  return _internal_block();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb* GetValidityPb::release_block() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetValidityPb.Block)
  
  ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb* temp = block_;
  block_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb* GetValidityPb::_internal_mutable_block() {
  
  if (block_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb>(GetArenaNoVirtual());
    block_ = p;
  }
  return block_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb* GetValidityPb::mutable_block() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetValidityPb.Block)
  return _internal_mutable_block();
}
inline void GetValidityPb::set_allocated_block(::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb* block) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(block_);
  }
  if (block) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      block = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, block, submessage_arena);
    }
    
  } else {
    
  }
  block_ = block;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.GetValidityPb.Block)
}

// double Security = 3;
inline void GetValidityPb::clear_security() {
  security_ = 0;
}
inline double GetValidityPb::_internal_security() const {
  return security_;
}
inline double GetValidityPb::security() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetValidityPb.Security)
  return _internal_security();
}
inline void GetValidityPb::_internal_set_security(double value) {
  
  security_ = value;
}
inline void GetValidityPb::set_security(double value) {
  _internal_set_security(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.GetValidityPb.Security)
}

// -------------------------------------------------------------------

// GetChecksumPb

// .OpenTestSystem.OtxDiagManager.Common.DFlashSessionPb FlashSession = 1;
inline bool GetChecksumPb::_internal_has_flashsession() const {
  return this != internal_default_instance() && flashsession_ != nullptr;
}
inline bool GetChecksumPb::has_flashsession() const {
  return _internal_has_flashsession();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& GetChecksumPb::_internal_flashsession() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* p = flashsession_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DFlashSessionPb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& GetChecksumPb::flashsession() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetChecksumPb.FlashSession)
  return _internal_flashsession();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* GetChecksumPb::release_flashsession() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetChecksumPb.FlashSession)
  
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* temp = flashsession_;
  flashsession_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* GetChecksumPb::_internal_mutable_flashsession() {
  
  if (flashsession_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb>(GetArenaNoVirtual());
    flashsession_ = p;
  }
  return flashsession_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* GetChecksumPb::mutable_flashsession() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetChecksumPb.FlashSession)
  return _internal_mutable_flashsession();
}
inline void GetChecksumPb::set_allocated_flashsession(::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(flashsession_);
  }
  if (flashsession) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      flashsession = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, flashsession, submessage_arena);
    }
    
  } else {
    
  }
  flashsession_ = flashsession;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.GetChecksumPb.FlashSession)
}

// .OpenTestSystem.OtxDiagManager.Common.DBlockCollectionPb Block = 2;
inline bool GetChecksumPb::_internal_has_block() const {
  return this != internal_default_instance() && block_ != nullptr;
}
inline bool GetChecksumPb::has_block() const {
  return _internal_has_block();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb& GetChecksumPb::_internal_block() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb* p = block_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DBlockCollectionPb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb& GetChecksumPb::block() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetChecksumPb.Block)
  return _internal_block();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb* GetChecksumPb::release_block() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetChecksumPb.Block)
  
  ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb* temp = block_;
  block_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb* GetChecksumPb::_internal_mutable_block() {
  
  if (block_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb>(GetArenaNoVirtual());
    block_ = p;
  }
  return block_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb* GetChecksumPb::mutable_block() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetChecksumPb.Block)
  return _internal_mutable_block();
}
inline void GetChecksumPb::set_allocated_block(::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb* block) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(block_);
  }
  if (block) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      block = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, block, submessage_arena);
    }
    
  } else {
    
  }
  block_ = block;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.GetChecksumPb.Block)
}

// double Security = 3;
inline void GetChecksumPb::clear_security() {
  security_ = 0;
}
inline double GetChecksumPb::_internal_security() const {
  return security_;
}
inline double GetChecksumPb::security() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetChecksumPb.Security)
  return _internal_security();
}
inline void GetChecksumPb::_internal_set_security(double value) {
  
  security_ = value;
}
inline void GetChecksumPb::set_security(double value) {
  _internal_set_security(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.GetChecksumPb.Security)
}

// -------------------------------------------------------------------

// GetSecurityMethodPb

// .OpenTestSystem.OtxDiagManager.Common.DFlashSessionPb FlashSession = 1;
inline bool GetSecurityMethodPb::_internal_has_flashsession() const {
  return this != internal_default_instance() && flashsession_ != nullptr;
}
inline bool GetSecurityMethodPb::has_flashsession() const {
  return _internal_has_flashsession();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& GetSecurityMethodPb::_internal_flashsession() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* p = flashsession_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DFlashSessionPb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& GetSecurityMethodPb::flashsession() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetSecurityMethodPb.FlashSession)
  return _internal_flashsession();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* GetSecurityMethodPb::release_flashsession() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetSecurityMethodPb.FlashSession)
  
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* temp = flashsession_;
  flashsession_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* GetSecurityMethodPb::_internal_mutable_flashsession() {
  
  if (flashsession_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb>(GetArenaNoVirtual());
    flashsession_ = p;
  }
  return flashsession_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* GetSecurityMethodPb::mutable_flashsession() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetSecurityMethodPb.FlashSession)
  return _internal_mutable_flashsession();
}
inline void GetSecurityMethodPb::set_allocated_flashsession(::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(flashsession_);
  }
  if (flashsession) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      flashsession = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, flashsession, submessage_arena);
    }
    
  } else {
    
  }
  flashsession_ = flashsession;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.GetSecurityMethodPb.FlashSession)
}

// .OpenTestSystem.OtxDiagManager.Common.DBlockCollectionPb Block = 2;
inline bool GetSecurityMethodPb::_internal_has_block() const {
  return this != internal_default_instance() && block_ != nullptr;
}
inline bool GetSecurityMethodPb::has_block() const {
  return _internal_has_block();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb& GetSecurityMethodPb::_internal_block() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb* p = block_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DBlockCollectionPb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb& GetSecurityMethodPb::block() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetSecurityMethodPb.Block)
  return _internal_block();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb* GetSecurityMethodPb::release_block() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetSecurityMethodPb.Block)
  
  ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb* temp = block_;
  block_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb* GetSecurityMethodPb::_internal_mutable_block() {
  
  if (block_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb>(GetArenaNoVirtual());
    block_ = p;
  }
  return block_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb* GetSecurityMethodPb::mutable_block() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetSecurityMethodPb.Block)
  return _internal_mutable_block();
}
inline void GetSecurityMethodPb::set_allocated_block(::OpenTestSystem::OtxDiagManager::Common::DBlockCollectionPb* block) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(block_);
  }
  if (block) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      block = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, block, submessage_arena);
    }
    
  } else {
    
  }
  block_ = block;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.GetSecurityMethodPb.Block)
}

// double Security = 3;
inline void GetSecurityMethodPb::clear_security() {
  security_ = 0;
}
inline double GetSecurityMethodPb::_internal_security() const {
  return security_;
}
inline double GetSecurityMethodPb::security() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetSecurityMethodPb.Security)
  return _internal_security();
}
inline void GetSecurityMethodPb::_internal_set_security(double value) {
  
  security_ = value;
}
inline void GetSecurityMethodPb::set_security(double value) {
  _internal_set_security(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.GetSecurityMethodPb.Security)
}

// -------------------------------------------------------------------

// GetOwnIdentFromEcuPb

// .OpenTestSystem.OtxDiagManager.Common.DFlashSessionPb FlashSession = 1;
inline bool GetOwnIdentFromEcuPb::_internal_has_flashsession() const {
  return this != internal_default_instance() && flashsession_ != nullptr;
}
inline bool GetOwnIdentFromEcuPb::has_flashsession() const {
  return _internal_has_flashsession();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& GetOwnIdentFromEcuPb::_internal_flashsession() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* p = flashsession_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DFlashSessionPb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& GetOwnIdentFromEcuPb::flashsession() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetOwnIdentFromEcuPb.FlashSession)
  return _internal_flashsession();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* GetOwnIdentFromEcuPb::release_flashsession() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetOwnIdentFromEcuPb.FlashSession)
  
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* temp = flashsession_;
  flashsession_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* GetOwnIdentFromEcuPb::_internal_mutable_flashsession() {
  
  if (flashsession_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb>(GetArenaNoVirtual());
    flashsession_ = p;
  }
  return flashsession_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* GetOwnIdentFromEcuPb::mutable_flashsession() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetOwnIdentFromEcuPb.FlashSession)
  return _internal_mutable_flashsession();
}
inline void GetOwnIdentFromEcuPb::set_allocated_flashsession(::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(flashsession_);
  }
  if (flashsession) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      flashsession = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, flashsession, submessage_arena);
    }
    
  } else {
    
  }
  flashsession_ = flashsession;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.GetOwnIdentFromEcuPb.FlashSession)
}

// double Block = 2;
inline void GetOwnIdentFromEcuPb::clear_block() {
  block_ = 0;
}
inline double GetOwnIdentFromEcuPb::_internal_block() const {
  return block_;
}
inline double GetOwnIdentFromEcuPb::block() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetOwnIdentFromEcuPb.Block)
  return _internal_block();
}
inline void GetOwnIdentFromEcuPb::_internal_set_block(double value) {
  
  block_ = value;
}
inline void GetOwnIdentFromEcuPb::set_block(double value) {
  _internal_set_block(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.GetOwnIdentFromEcuPb.Block)
}

// double Number = 3;
inline void GetOwnIdentFromEcuPb::clear_number() {
  number_ = 0;
}
inline double GetOwnIdentFromEcuPb::_internal_number() const {
  return number_;
}
inline double GetOwnIdentFromEcuPb::number() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetOwnIdentFromEcuPb.Number)
  return _internal_number();
}
inline void GetOwnIdentFromEcuPb::_internal_set_number(double value) {
  
  number_ = value;
}
inline void GetOwnIdentFromEcuPb::set_number(double value) {
  _internal_set_number(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.GetOwnIdentFromEcuPb.Number)
}

// -------------------------------------------------------------------

// GetOwnIdentPb

// .OpenTestSystem.OtxDiagManager.Common.DFlashSessionPb FlashSession = 1;
inline bool GetOwnIdentPb::_internal_has_flashsession() const {
  return this != internal_default_instance() && flashsession_ != nullptr;
}
inline bool GetOwnIdentPb::has_flashsession() const {
  return _internal_has_flashsession();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& GetOwnIdentPb::_internal_flashsession() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* p = flashsession_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DFlashSessionPb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& GetOwnIdentPb::flashsession() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetOwnIdentPb.FlashSession)
  return _internal_flashsession();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* GetOwnIdentPb::release_flashsession() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetOwnIdentPb.FlashSession)
  
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* temp = flashsession_;
  flashsession_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* GetOwnIdentPb::_internal_mutable_flashsession() {
  
  if (flashsession_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb>(GetArenaNoVirtual());
    flashsession_ = p;
  }
  return flashsession_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* GetOwnIdentPb::mutable_flashsession() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetOwnIdentPb.FlashSession)
  return _internal_mutable_flashsession();
}
inline void GetOwnIdentPb::set_allocated_flashsession(::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(flashsession_);
  }
  if (flashsession) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      flashsession = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, flashsession, submessage_arena);
    }
    
  } else {
    
  }
  flashsession_ = flashsession;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.GetOwnIdentPb.FlashSession)
}

// double Block = 2;
inline void GetOwnIdentPb::clear_block() {
  block_ = 0;
}
inline double GetOwnIdentPb::_internal_block() const {
  return block_;
}
inline double GetOwnIdentPb::block() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetOwnIdentPb.Block)
  return _internal_block();
}
inline void GetOwnIdentPb::_internal_set_block(double value) {
  
  block_ = value;
}
inline void GetOwnIdentPb::set_block(double value) {
  _internal_set_block(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.GetOwnIdentPb.Block)
}

// double Number = 3;
inline void GetOwnIdentPb::clear_number() {
  number_ = 0;
}
inline double GetOwnIdentPb::_internal_number() const {
  return number_;
}
inline double GetOwnIdentPb::number() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetOwnIdentPb.Number)
  return _internal_number();
}
inline void GetOwnIdentPb::_internal_set_number(double value) {
  
  number_ = value;
}
inline void GetOwnIdentPb::set_number(double value) {
  _internal_set_number(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.GetOwnIdentPb.Number)
}

// -------------------------------------------------------------------

// GetDownloadDataPb

// .OpenTestSystem.OtxDiagManager.Common.DFlashSessionPb FlashSession = 1;
inline bool GetDownloadDataPb::_internal_has_flashsession() const {
  return this != internal_default_instance() && flashsession_ != nullptr;
}
inline bool GetDownloadDataPb::has_flashsession() const {
  return _internal_has_flashsession();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& GetDownloadDataPb::_internal_flashsession() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* p = flashsession_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DFlashSessionPb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& GetDownloadDataPb::flashsession() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetDownloadDataPb.FlashSession)
  return _internal_flashsession();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* GetDownloadDataPb::release_flashsession() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetDownloadDataPb.FlashSession)
  
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* temp = flashsession_;
  flashsession_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* GetDownloadDataPb::_internal_mutable_flashsession() {
  
  if (flashsession_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb>(GetArenaNoVirtual());
    flashsession_ = p;
  }
  return flashsession_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* GetDownloadDataPb::mutable_flashsession() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetDownloadDataPb.FlashSession)
  return _internal_mutable_flashsession();
}
inline void GetDownloadDataPb::set_allocated_flashsession(::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(flashsession_);
  }
  if (flashsession) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      flashsession = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, flashsession, submessage_arena);
    }
    
  } else {
    
  }
  flashsession_ = flashsession;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.GetDownloadDataPb.FlashSession)
}

// double Block = 2;
inline void GetDownloadDataPb::clear_block() {
  block_ = 0;
}
inline double GetDownloadDataPb::_internal_block() const {
  return block_;
}
inline double GetDownloadDataPb::block() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetDownloadDataPb.Block)
  return _internal_block();
}
inline void GetDownloadDataPb::_internal_set_block(double value) {
  
  block_ = value;
}
inline void GetDownloadDataPb::set_block(double value) {
  _internal_set_block(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.GetDownloadDataPb.Block)
}

// double Segment = 3;
inline void GetDownloadDataPb::clear_segment() {
  segment_ = 0;
}
inline double GetDownloadDataPb::_internal_segment() const {
  return segment_;
}
inline double GetDownloadDataPb::segment() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetDownloadDataPb.Segment)
  return _internal_segment();
}
inline void GetDownloadDataPb::_internal_set_segment(double value) {
  
  segment_ = value;
}
inline void GetDownloadDataPb::set_segment(double value) {
  _internal_set_segment(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.GetDownloadDataPb.Segment)
}

// double Size = 4;
inline void GetDownloadDataPb::clear_size() {
  size_ = 0;
}
inline double GetDownloadDataPb::_internal_size() const {
  return size_;
}
inline double GetDownloadDataPb::size() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetDownloadDataPb.Size)
  return _internal_size();
}
inline void GetDownloadDataPb::_internal_set_size(double value) {
  
  size_ = value;
}
inline void GetDownloadDataPb::set_size(double value) {
  _internal_set_size(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.GetDownloadDataPb.Size)
}

// double Position = 5;
inline void GetDownloadDataPb::clear_position() {
  position_ = 0;
}
inline double GetDownloadDataPb::_internal_position() const {
  return position_;
}
inline double GetDownloadDataPb::position() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetDownloadDataPb.Position)
  return _internal_position();
}
inline void GetDownloadDataPb::_internal_set_position(double value) {
  
  position_ = value;
}
inline void GetDownloadDataPb::set_position(double value) {
  _internal_set_position(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.GetDownloadDataPb.Position)
}

// bytes Data = 6;
inline void GetDownloadDataPb::clear_data() {
  data_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& GetDownloadDataPb::data() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetDownloadDataPb.Data)
  return _internal_data();
}
inline void GetDownloadDataPb::set_data(const std::string& value) {
  _internal_set_data(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.GetDownloadDataPb.Data)
}
inline std::string* GetDownloadDataPb::mutable_data() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetDownloadDataPb.Data)
  return _internal_mutable_data();
}
inline const std::string& GetDownloadDataPb::_internal_data() const {
  return data_.GetNoArena();
}
inline void GetDownloadDataPb::_internal_set_data(const std::string& value) {
  
  data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void GetDownloadDataPb::set_data(std::string&& value) {
  
  data_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.GetDownloadDataPb.Data)
}
inline void GetDownloadDataPb::set_data(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.GetDownloadDataPb.Data)
}
inline void GetDownloadDataPb::set_data(const void* value, size_t size) {
  
  data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.GetDownloadDataPb.Data)
}
inline std::string* GetDownloadDataPb::_internal_mutable_data() {
  
  return data_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* GetDownloadDataPb::release_data() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetDownloadDataPb.Data)
  
  return data_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void GetDownloadDataPb::set_allocated_data(std::string* data) {
  if (data != nullptr) {
    
  } else {
    
  }
  data_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), data);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.GetDownloadDataPb.Data)
}

// -------------------------------------------------------------------

// CreateFlashJobPb

// .OpenTestSystem.OtxDiagManager.Common.DComChannelPb ComChannel = 1;
inline bool CreateFlashJobPb::_internal_has_comchannel() const {
  return this != internal_default_instance() && comchannel_ != nullptr;
}
inline bool CreateFlashJobPb::has_comchannel() const {
  return _internal_has_comchannel();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& CreateFlashJobPb::_internal_comchannel() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* p = comchannel_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DComChannelPb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& CreateFlashJobPb::comchannel() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.CreateFlashJobPb.ComChannel)
  return _internal_comchannel();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* CreateFlashJobPb::release_comchannel() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.CreateFlashJobPb.ComChannel)
  
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* temp = comchannel_;
  comchannel_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* CreateFlashJobPb::_internal_mutable_comchannel() {
  
  if (comchannel_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DComChannelPb>(GetArenaNoVirtual());
    comchannel_ = p;
  }
  return comchannel_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* CreateFlashJobPb::mutable_comchannel() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.CreateFlashJobPb.ComChannel)
  return _internal_mutable_comchannel();
}
inline void CreateFlashJobPb::set_allocated_comchannel(::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* comchannel) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(comchannel_);
  }
  if (comchannel) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      comchannel = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, comchannel, submessage_arena);
    }
    
  } else {
    
  }
  comchannel_ = comchannel;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.CreateFlashJobPb.ComChannel)
}

// .OpenTestSystem.OtxDiagManager.Common.DFlashSessionPb FlashSession = 2;
inline bool CreateFlashJobPb::_internal_has_flashsession() const {
  return this != internal_default_instance() && flashsession_ != nullptr;
}
inline bool CreateFlashJobPb::has_flashsession() const {
  return _internal_has_flashsession();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& CreateFlashJobPb::_internal_flashsession() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* p = flashsession_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DFlashSessionPb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& CreateFlashJobPb::flashsession() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.CreateFlashJobPb.FlashSession)
  return _internal_flashsession();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* CreateFlashJobPb::release_flashsession() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.CreateFlashJobPb.FlashSession)
  
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* temp = flashsession_;
  flashsession_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* CreateFlashJobPb::_internal_mutable_flashsession() {
  
  if (flashsession_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb>(GetArenaNoVirtual());
    flashsession_ = p;
  }
  return flashsession_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* CreateFlashJobPb::mutable_flashsession() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.CreateFlashJobPb.FlashSession)
  return _internal_mutable_flashsession();
}
inline void CreateFlashJobPb::set_allocated_flashsession(::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(flashsession_);
  }
  if (flashsession) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      flashsession = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, flashsession, submessage_arena);
    }
    
  } else {
    
  }
  flashsession_ = flashsession;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.CreateFlashJobPb.FlashSession)
}

// -------------------------------------------------------------------

// CreateFlashJobByNamePb

// .OpenTestSystem.OtxDiagManager.Common.DComChannelPb ComChannel = 1;
inline bool CreateFlashJobByNamePb::_internal_has_comchannel() const {
  return this != internal_default_instance() && comchannel_ != nullptr;
}
inline bool CreateFlashJobByNamePb::has_comchannel() const {
  return _internal_has_comchannel();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& CreateFlashJobByNamePb::_internal_comchannel() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* p = comchannel_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DComChannelPb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& CreateFlashJobByNamePb::comchannel() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.CreateFlashJobByNamePb.ComChannel)
  return _internal_comchannel();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* CreateFlashJobByNamePb::release_comchannel() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.CreateFlashJobByNamePb.ComChannel)
  
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* temp = comchannel_;
  comchannel_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* CreateFlashJobByNamePb::_internal_mutable_comchannel() {
  
  if (comchannel_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DComChannelPb>(GetArenaNoVirtual());
    comchannel_ = p;
  }
  return comchannel_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* CreateFlashJobByNamePb::mutable_comchannel() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.CreateFlashJobByNamePb.ComChannel)
  return _internal_mutable_comchannel();
}
inline void CreateFlashJobByNamePb::set_allocated_comchannel(::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* comchannel) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(comchannel_);
  }
  if (comchannel) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      comchannel = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, comchannel, submessage_arena);
    }
    
  } else {
    
  }
  comchannel_ = comchannel;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.CreateFlashJobByNamePb.ComChannel)
}

// string Name = 2;
inline void CreateFlashJobByNamePb::clear_name() {
  name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& CreateFlashJobByNamePb::name() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.CreateFlashJobByNamePb.Name)
  return _internal_name();
}
inline void CreateFlashJobByNamePb::set_name(const std::string& value) {
  _internal_set_name(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.CreateFlashJobByNamePb.Name)
}
inline std::string* CreateFlashJobByNamePb::mutable_name() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.CreateFlashJobByNamePb.Name)
  return _internal_mutable_name();
}
inline const std::string& CreateFlashJobByNamePb::_internal_name() const {
  return name_.GetNoArena();
}
inline void CreateFlashJobByNamePb::_internal_set_name(const std::string& value) {
  
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void CreateFlashJobByNamePb::set_name(std::string&& value) {
  
  name_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.CreateFlashJobByNamePb.Name)
}
inline void CreateFlashJobByNamePb::set_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.CreateFlashJobByNamePb.Name)
}
inline void CreateFlashJobByNamePb::set_name(const char* value, size_t size) {
  
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.CreateFlashJobByNamePb.Name)
}
inline std::string* CreateFlashJobByNamePb::_internal_mutable_name() {
  
  return name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* CreateFlashJobByNamePb::release_name() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.CreateFlashJobByNamePb.Name)
  
  return name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void CreateFlashJobByNamePb::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.CreateFlashJobByNamePb.Name)
}

// .OpenTestSystem.OtxDiagManager.Common.DFlashSessionPb FlashSession = 3;
inline bool CreateFlashJobByNamePb::_internal_has_flashsession() const {
  return this != internal_default_instance() && flashsession_ != nullptr;
}
inline bool CreateFlashJobByNamePb::has_flashsession() const {
  return _internal_has_flashsession();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& CreateFlashJobByNamePb::_internal_flashsession() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* p = flashsession_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DFlashSessionPb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& CreateFlashJobByNamePb::flashsession() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.CreateFlashJobByNamePb.FlashSession)
  return _internal_flashsession();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* CreateFlashJobByNamePb::release_flashsession() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.CreateFlashJobByNamePb.FlashSession)
  
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* temp = flashsession_;
  flashsession_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* CreateFlashJobByNamePb::_internal_mutable_flashsession() {
  
  if (flashsession_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb>(GetArenaNoVirtual());
    flashsession_ = p;
  }
  return flashsession_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* CreateFlashJobByNamePb::mutable_flashsession() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.CreateFlashJobByNamePb.FlashSession)
  return _internal_mutable_flashsession();
}
inline void CreateFlashJobByNamePb::set_allocated_flashsession(::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(flashsession_);
  }
  if (flashsession) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      flashsession = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, flashsession, submessage_arena);
    }
    
  } else {
    
  }
  flashsession_ = flashsession;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.CreateFlashJobByNamePb.FlashSession)
}

// -------------------------------------------------------------------

// CreateFlashJobBySemanticPb

// .OpenTestSystem.OtxDiagManager.Common.DComChannelPb ComChannel = 1;
inline bool CreateFlashJobBySemanticPb::_internal_has_comchannel() const {
  return this != internal_default_instance() && comchannel_ != nullptr;
}
inline bool CreateFlashJobBySemanticPb::has_comchannel() const {
  return _internal_has_comchannel();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& CreateFlashJobBySemanticPb::_internal_comchannel() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* p = comchannel_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DComChannelPb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& CreateFlashJobBySemanticPb::comchannel() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.CreateFlashJobBySemanticPb.ComChannel)
  return _internal_comchannel();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* CreateFlashJobBySemanticPb::release_comchannel() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.CreateFlashJobBySemanticPb.ComChannel)
  
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* temp = comchannel_;
  comchannel_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* CreateFlashJobBySemanticPb::_internal_mutable_comchannel() {
  
  if (comchannel_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DComChannelPb>(GetArenaNoVirtual());
    comchannel_ = p;
  }
  return comchannel_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* CreateFlashJobBySemanticPb::mutable_comchannel() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.CreateFlashJobBySemanticPb.ComChannel)
  return _internal_mutable_comchannel();
}
inline void CreateFlashJobBySemanticPb::set_allocated_comchannel(::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* comchannel) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(comchannel_);
  }
  if (comchannel) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      comchannel = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, comchannel, submessage_arena);
    }
    
  } else {
    
  }
  comchannel_ = comchannel;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.CreateFlashJobBySemanticPb.ComChannel)
}

// string Semantic = 2;
inline void CreateFlashJobBySemanticPb::clear_semantic() {
  semantic_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& CreateFlashJobBySemanticPb::semantic() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.CreateFlashJobBySemanticPb.Semantic)
  return _internal_semantic();
}
inline void CreateFlashJobBySemanticPb::set_semantic(const std::string& value) {
  _internal_set_semantic(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.CreateFlashJobBySemanticPb.Semantic)
}
inline std::string* CreateFlashJobBySemanticPb::mutable_semantic() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.CreateFlashJobBySemanticPb.Semantic)
  return _internal_mutable_semantic();
}
inline const std::string& CreateFlashJobBySemanticPb::_internal_semantic() const {
  return semantic_.GetNoArena();
}
inline void CreateFlashJobBySemanticPb::_internal_set_semantic(const std::string& value) {
  
  semantic_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void CreateFlashJobBySemanticPb::set_semantic(std::string&& value) {
  
  semantic_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.CreateFlashJobBySemanticPb.Semantic)
}
inline void CreateFlashJobBySemanticPb::set_semantic(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  semantic_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.CreateFlashJobBySemanticPb.Semantic)
}
inline void CreateFlashJobBySemanticPb::set_semantic(const char* value, size_t size) {
  
  semantic_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.CreateFlashJobBySemanticPb.Semantic)
}
inline std::string* CreateFlashJobBySemanticPb::_internal_mutable_semantic() {
  
  return semantic_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* CreateFlashJobBySemanticPb::release_semantic() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.CreateFlashJobBySemanticPb.Semantic)
  
  return semantic_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void CreateFlashJobBySemanticPb::set_allocated_semantic(std::string* semantic) {
  if (semantic != nullptr) {
    
  } else {
    
  }
  semantic_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), semantic);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.CreateFlashJobBySemanticPb.Semantic)
}

// .OpenTestSystem.OtxDiagManager.Common.DFlashSessionPb FlashSession = 3;
inline bool CreateFlashJobBySemanticPb::_internal_has_flashsession() const {
  return this != internal_default_instance() && flashsession_ != nullptr;
}
inline bool CreateFlashJobBySemanticPb::has_flashsession() const {
  return _internal_has_flashsession();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& CreateFlashJobBySemanticPb::_internal_flashsession() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* p = flashsession_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DFlashSessionPb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& CreateFlashJobBySemanticPb::flashsession() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.CreateFlashJobBySemanticPb.FlashSession)
  return _internal_flashsession();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* CreateFlashJobBySemanticPb::release_flashsession() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.CreateFlashJobBySemanticPb.FlashSession)
  
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* temp = flashsession_;
  flashsession_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* CreateFlashJobBySemanticPb::_internal_mutable_flashsession() {
  
  if (flashsession_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb>(GetArenaNoVirtual());
    flashsession_ = p;
  }
  return flashsession_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* CreateFlashJobBySemanticPb::mutable_flashsession() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.CreateFlashJobBySemanticPb.FlashSession)
  return _internal_mutable_flashsession();
}
inline void CreateFlashJobBySemanticPb::set_allocated_flashsession(::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(flashsession_);
  }
  if (flashsession) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      flashsession = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, flashsession, submessage_arena);
    }
    
  } else {
    
  }
  flashsession_ = flashsession;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.CreateFlashJobBySemanticPb.FlashSession)
}

// -------------------------------------------------------------------

// SetFlashSessionPb

// .OpenTestSystem.OtxDiagManager.Common.DFlashJobPb FlashJob = 1;
inline bool SetFlashSessionPb::_internal_has_flashjob() const {
  return this != internal_default_instance() && flashjob_ != nullptr;
}
inline bool SetFlashSessionPb::has_flashjob() const {
  return _internal_has_flashjob();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DFlashJobPb& SetFlashSessionPb::_internal_flashjob() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashJobPb* p = flashjob_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DFlashJobPb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DFlashJobPb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DFlashJobPb& SetFlashSessionPb::flashjob() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.SetFlashSessionPb.FlashJob)
  return _internal_flashjob();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashJobPb* SetFlashSessionPb::release_flashjob() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.SetFlashSessionPb.FlashJob)
  
  ::OpenTestSystem::OtxDiagManager::Common::DFlashJobPb* temp = flashjob_;
  flashjob_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashJobPb* SetFlashSessionPb::_internal_mutable_flashjob() {
  
  if (flashjob_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DFlashJobPb>(GetArenaNoVirtual());
    flashjob_ = p;
  }
  return flashjob_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashJobPb* SetFlashSessionPb::mutable_flashjob() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.SetFlashSessionPb.FlashJob)
  return _internal_mutable_flashjob();
}
inline void SetFlashSessionPb::set_allocated_flashjob(::OpenTestSystem::OtxDiagManager::Common::DFlashJobPb* flashjob) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(flashjob_);
  }
  if (flashjob) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      flashjob = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, flashjob, submessage_arena);
    }
    
  } else {
    
  }
  flashjob_ = flashjob;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.SetFlashSessionPb.FlashJob)
}

// .OpenTestSystem.OtxDiagManager.Common.DFlashSessionPb FlashSession = 2;
inline bool SetFlashSessionPb::_internal_has_flashsession() const {
  return this != internal_default_instance() && flashsession_ != nullptr;
}
inline bool SetFlashSessionPb::has_flashsession() const {
  return _internal_has_flashsession();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& SetFlashSessionPb::_internal_flashsession() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* p = flashsession_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DFlashSessionPb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb& SetFlashSessionPb::flashsession() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.SetFlashSessionPb.FlashSession)
  return _internal_flashsession();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* SetFlashSessionPb::release_flashsession() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.SetFlashSessionPb.FlashSession)
  
  ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* temp = flashsession_;
  flashsession_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* SetFlashSessionPb::_internal_mutable_flashsession() {
  
  if (flashsession_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb>(GetArenaNoVirtual());
    flashsession_ = p;
  }
  return flashsession_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* SetFlashSessionPb::mutable_flashsession() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.SetFlashSessionPb.FlashSession)
  return _internal_mutable_flashsession();
}
inline void SetFlashSessionPb::set_allocated_flashsession(::OpenTestSystem::OtxDiagManager::Common::DFlashSessionPb* flashsession) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(flashsession_);
  }
  if (flashsession) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      flashsession = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, flashsession, submessage_arena);
    }
    
  } else {
    
  }
  flashsession_ = flashsession;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.SetFlashSessionPb.FlashSession)
}

#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------


// @@protoc_insertion_point(namespace_scope)

}  // namespace Common
}  // namespace OtxDiagManager
}  // namespace OpenTestSystem

// @@protoc_insertion_point(global_scope)

#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_FlashCommandsPb_2eproto
