// Generated by the protocol buffer compiler.  DO NOT EDIT!
// NO CHECKED-IN PROTOBUF GENCODE
// source: mgard.proto
// Protobuf C++ Version: 7.36.0

#ifndef mgard_2eproto_2epb_2eh
#define mgard_2eproto_2epb_2eh

#include <limits>
#include <string>
#include <type_traits>
#include <utility>

// clang-format off
#include "google/protobuf/runtime_version.h"
#if PROTOBUF_VERSION != 7036000
#error "Protobuf C++ gencode is built with an incompatible version of"
#error "Protobuf C++ headers/runtime. See"
#error "https://protobuf.dev/support/cross-version-runtime-guarantee/#cpp"
#endif
#include "google/protobuf/io/coded_stream.h"
#include "google/protobuf/arena.h"
#include "google/protobuf/arenastring.h"
#include "google/protobuf/generated_message_tctable_decl.h"
#include "google/protobuf/generated_message_util.h"
#include "google/protobuf/metadata_lite.h"
#include "google/protobuf/generated_message_reflection.h"
#include "google/protobuf/message.h"
#include "google/protobuf/message_lite.h"
#include "google/protobuf/repeated_field.h"  // IWYU pragma: export
#include "google/protobuf/extension_set.h"  // IWYU pragma: export
#include "google/protobuf/generated_enum_reflection.h"
#include "google/protobuf/unknown_field_set.h"
// @@protoc_insertion_point(includes)

// Must be included last.
#include "google/protobuf/port_def.inc"

#define PROTOBUF_INTERNAL_EXPORT_mgard_2eproto

// Internal implementation detail -- do not use these members.
struct TableStruct_mgard_2eproto {
  static const ::uint32_t offsets[];
};
extern "C" {
extern const ::google::protobuf::internal::DescriptorTable descriptor_table_mgard_2eproto;
}  // extern "C"
namespace mgard {
namespace pb {
enum BitplaneEncoding_Method : int;
extern const uint32_t BitplaneEncoding_Method_internal_data_[];
enum BitplaneEncoding_Type : int;
extern const uint32_t BitplaneEncoding_Type_internal_data_[];
enum Dataset_Type : int;
extern const uint32_t Dataset_Type_internal_data_[];
enum Device_Backend : int;
extern const uint32_t Device_Backend_internal_data_[];
enum DomainDecomposition_Method : int;
extern const uint32_t DomainDecomposition_Method_internal_data_[];
enum Domain_Geometry : int;
extern const uint32_t Domain_Geometry_internal_data_[];
enum Domain_Topology : int;
extern const uint32_t Domain_Topology_internal_data_[];
enum Encoding_Compressor : int;
extern const uint32_t Encoding_Compressor_internal_data_[];
enum Encoding_Preprocessor : int;
extern const uint32_t Encoding_Preprocessor_internal_data_[];
enum ErrorControl_Mode : int;
extern const uint32_t ErrorControl_Mode_internal_data_[];
enum ErrorControl_Norm : int;
extern const uint32_t ErrorControl_Norm_internal_data_[];
enum FunctionDecomposition_Hierarchy : int;
extern const uint32_t FunctionDecomposition_Hierarchy_internal_data_[];
enum FunctionDecomposition_Transform : int;
extern const uint32_t FunctionDecomposition_Transform_internal_data_[];
enum Quantization_BinWidths : int;
extern const uint32_t Quantization_BinWidths_internal_data_[];
enum Quantization_Method : int;
extern const uint32_t Quantization_Method_internal_data_[];
enum Quantization_Type : int;
extern const uint32_t Quantization_Type_internal_data_[];
class BitplaneEncoding;
struct BitplaneEncodingGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern BitplaneEncodingGlobalsTypeInternal BitplaneEncoding_globals_;
extern const ::google::protobuf::internal::ClassDataFull BitplaneEncoding_class_data_;
#else
extern const BitplaneEncodingGlobalsTypeInternal BitplaneEncoding_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class CartesianGridTopology;
struct CartesianGridTopologyGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern CartesianGridTopologyGlobalsTypeInternal CartesianGridTopology_globals_;
extern const ::google::protobuf::internal::ClassDataFull CartesianGridTopology_class_data_;
#else
extern const CartesianGridTopologyGlobalsTypeInternal CartesianGridTopology_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class Dataset;
struct DatasetGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern DatasetGlobalsTypeInternal Dataset_globals_;
extern const ::google::protobuf::internal::ClassDataFull Dataset_class_data_;
#else
extern const DatasetGlobalsTypeInternal Dataset_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class Device;
struct DeviceGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern DeviceGlobalsTypeInternal Device_globals_;
extern const ::google::protobuf::internal::ClassDataFull Device_class_data_;
#else
extern const DeviceGlobalsTypeInternal Device_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class Domain;
struct DomainGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern DomainGlobalsTypeInternal Domain_globals_;
extern const ::google::protobuf::internal::ClassDataFull Domain_class_data_;
#else
extern const DomainGlobalsTypeInternal Domain_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class DomainDecomposition;
struct DomainDecompositionGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern DomainDecompositionGlobalsTypeInternal DomainDecomposition_globals_;
extern const ::google::protobuf::internal::ClassDataFull DomainDecomposition_class_data_;
#else
extern const DomainDecompositionGlobalsTypeInternal DomainDecomposition_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class Encoding;
struct EncodingGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern EncodingGlobalsTypeInternal Encoding_globals_;
extern const ::google::protobuf::internal::ClassDataFull Encoding_class_data_;
#else
extern const EncodingGlobalsTypeInternal Encoding_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class ErrorControl;
struct ErrorControlGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern ErrorControlGlobalsTypeInternal ErrorControl_globals_;
extern const ::google::protobuf::internal::ClassDataFull ErrorControl_class_data_;
#else
extern const ErrorControlGlobalsTypeInternal ErrorControl_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class ExplicitCubeGeometry;
struct ExplicitCubeGeometryGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern ExplicitCubeGeometryGlobalsTypeInternal ExplicitCubeGeometry_globals_;
extern const ::google::protobuf::internal::ClassDataFull ExplicitCubeGeometry_class_data_;
#else
extern const ExplicitCubeGeometryGlobalsTypeInternal ExplicitCubeGeometry_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class FunctionDecomposition;
struct FunctionDecompositionGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern FunctionDecompositionGlobalsTypeInternal FunctionDecomposition_globals_;
extern const ::google::protobuf::internal::ClassDataFull FunctionDecomposition_class_data_;
#else
extern const FunctionDecompositionGlobalsTypeInternal FunctionDecomposition_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class Header;
struct HeaderGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern HeaderGlobalsTypeInternal Header_globals_;
extern const ::google::protobuf::internal::ClassDataFull Header_class_data_;
#else
extern const HeaderGlobalsTypeInternal Header_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class Quantization;
struct QuantizationGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern QuantizationGlobalsTypeInternal Quantization_globals_;
extern const ::google::protobuf::internal::ClassDataFull Quantization_class_data_;
#else
extern const QuantizationGlobalsTypeInternal Quantization_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class VersionNumber;
struct VersionNumberGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern VersionNumberGlobalsTypeInternal VersionNumber_globals_;
extern const ::google::protobuf::internal::ClassDataFull VersionNumber_class_data_;
#else
extern const VersionNumberGlobalsTypeInternal VersionNumber_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
}  // namespace pb
}  // namespace mgard
namespace google {
namespace protobuf {
template <>
internal::EnumTraitsT<::mgard::pb::BitplaneEncoding_Method_internal_data_>
    internal::EnumTraitsImpl::value<::mgard::pb::BitplaneEncoding_Method>;
template <>
internal::EnumTraitsT<::mgard::pb::BitplaneEncoding_Type_internal_data_>
    internal::EnumTraitsImpl::value<::mgard::pb::BitplaneEncoding_Type>;
template <>
internal::EnumTraitsT<::mgard::pb::Dataset_Type_internal_data_>
    internal::EnumTraitsImpl::value<::mgard::pb::Dataset_Type>;
template <>
internal::EnumTraitsT<::mgard::pb::Device_Backend_internal_data_>
    internal::EnumTraitsImpl::value<::mgard::pb::Device_Backend>;
template <>
internal::EnumTraitsT<::mgard::pb::DomainDecomposition_Method_internal_data_>
    internal::EnumTraitsImpl::value<::mgard::pb::DomainDecomposition_Method>;
template <>
internal::EnumTraitsT<::mgard::pb::Domain_Geometry_internal_data_>
    internal::EnumTraitsImpl::value<::mgard::pb::Domain_Geometry>;
template <>
internal::EnumTraitsT<::mgard::pb::Domain_Topology_internal_data_>
    internal::EnumTraitsImpl::value<::mgard::pb::Domain_Topology>;
template <>
internal::EnumTraitsT<::mgard::pb::Encoding_Compressor_internal_data_>
    internal::EnumTraitsImpl::value<::mgard::pb::Encoding_Compressor>;
template <>
internal::EnumTraitsT<::mgard::pb::Encoding_Preprocessor_internal_data_>
    internal::EnumTraitsImpl::value<::mgard::pb::Encoding_Preprocessor>;
template <>
internal::EnumTraitsT<::mgard::pb::ErrorControl_Mode_internal_data_>
    internal::EnumTraitsImpl::value<::mgard::pb::ErrorControl_Mode>;
template <>
internal::EnumTraitsT<::mgard::pb::ErrorControl_Norm_internal_data_>
    internal::EnumTraitsImpl::value<::mgard::pb::ErrorControl_Norm>;
template <>
internal::EnumTraitsT<::mgard::pb::FunctionDecomposition_Hierarchy_internal_data_>
    internal::EnumTraitsImpl::value<::mgard::pb::FunctionDecomposition_Hierarchy>;
template <>
internal::EnumTraitsT<::mgard::pb::FunctionDecomposition_Transform_internal_data_>
    internal::EnumTraitsImpl::value<::mgard::pb::FunctionDecomposition_Transform>;
template <>
internal::EnumTraitsT<::mgard::pb::Quantization_BinWidths_internal_data_>
    internal::EnumTraitsImpl::value<::mgard::pb::Quantization_BinWidths>;
template <>
internal::EnumTraitsT<::mgard::pb::Quantization_Method_internal_data_>
    internal::EnumTraitsImpl::value<::mgard::pb::Quantization_Method>;
template <>
internal::EnumTraitsT<::mgard::pb::Quantization_Type_internal_data_>
    internal::EnumTraitsImpl::value<::mgard::pb::Quantization_Type>;
}  // namespace protobuf
}  // namespace google

namespace mgard {
namespace pb {
enum Domain_Topology : int {
  Domain_Topology_CARTESIAN_GRID = 0,
  Domain_Topology_Domain_Topology_INT_MIN_SENTINEL_DO_NOT_USE_ =
      ::std::numeric_limits<::int32_t>::min(),
  Domain_Topology_Domain_Topology_INT_MAX_SENTINEL_DO_NOT_USE_ =
      ::std::numeric_limits<::int32_t>::max(),
};

extern const uint32_t Domain_Topology_internal_data_[];
inline constexpr Domain_Topology Domain_Topology_Topology_MIN =
    static_cast<Domain_Topology>(0);
inline constexpr Domain_Topology Domain_Topology_Topology_MAX =
    static_cast<Domain_Topology>(0);
[[nodiscard]] inline bool Domain_Topology_IsValid(int value) {
  return 0 <= value && value <= 0;
}
inline constexpr int Domain_Topology_Topology_ARRAYSIZE = 0 + 1;
[[nodiscard]] const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL
Domain_Topology_descriptor();
[[nodiscard]] inline auto ProtobufInternalGetEnumDescriptor(Domain_Topology) {
  return Domain_Topology_descriptor();
}
template <typename T>
[[nodiscard]] const ::std::string& Domain_Topology_Name(T value) {
  static_assert(::std::is_same<T, Domain_Topology>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to Topology_Name().");
  return Domain_Topology_Name(static_cast<Domain_Topology>(value));
}
template <>
[[nodiscard]] inline const ::std::string& Domain_Topology_Name(Domain_Topology value) {
  return ::google::protobuf::internal::NameOfDenseEnum<Domain_Topology_descriptor, 0, 0>(
      static_cast<int>(value));
}
[[nodiscard]] inline bool Domain_Topology_Parse(
    ::absl::string_view name, Domain_Topology* PROTOBUF_NONNULL value) {
  return ::google::protobuf::internal::ParseNamedEnum<Domain_Topology>(Domain_Topology_descriptor(), name,
                                           value);
}
enum Domain_Geometry : int {
  Domain_Geometry_UNIT_CUBE = 0,
  Domain_Geometry_EXPLICIT_CUBE = 1,
  Domain_Geometry_Domain_Geometry_INT_MIN_SENTINEL_DO_NOT_USE_ =
      ::std::numeric_limits<::int32_t>::min(),
  Domain_Geometry_Domain_Geometry_INT_MAX_SENTINEL_DO_NOT_USE_ =
      ::std::numeric_limits<::int32_t>::max(),
};

extern const uint32_t Domain_Geometry_internal_data_[];
inline constexpr Domain_Geometry Domain_Geometry_Geometry_MIN =
    static_cast<Domain_Geometry>(0);
inline constexpr Domain_Geometry Domain_Geometry_Geometry_MAX =
    static_cast<Domain_Geometry>(1);
[[nodiscard]] inline bool Domain_Geometry_IsValid(int value) {
  return 0 <= value && value <= 1;
}
inline constexpr int Domain_Geometry_Geometry_ARRAYSIZE = 1 + 1;
[[nodiscard]] const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL
Domain_Geometry_descriptor();
[[nodiscard]] inline auto ProtobufInternalGetEnumDescriptor(Domain_Geometry) {
  return Domain_Geometry_descriptor();
}
template <typename T>
[[nodiscard]] const ::std::string& Domain_Geometry_Name(T value) {
  static_assert(::std::is_same<T, Domain_Geometry>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to Geometry_Name().");
  return Domain_Geometry_Name(static_cast<Domain_Geometry>(value));
}
template <>
[[nodiscard]] inline const ::std::string& Domain_Geometry_Name(Domain_Geometry value) {
  return ::google::protobuf::internal::NameOfDenseEnum<Domain_Geometry_descriptor, 0, 1>(
      static_cast<int>(value));
}
[[nodiscard]] inline bool Domain_Geometry_Parse(
    ::absl::string_view name, Domain_Geometry* PROTOBUF_NONNULL value) {
  return ::google::protobuf::internal::ParseNamedEnum<Domain_Geometry>(Domain_Geometry_descriptor(), name,
                                           value);
}
enum Dataset_Type : int {
  Dataset_Type_FLOAT = 0,
  Dataset_Type_DOUBLE = 1,
  Dataset_Type_Dataset_Type_INT_MIN_SENTINEL_DO_NOT_USE_ =
      ::std::numeric_limits<::int32_t>::min(),
  Dataset_Type_Dataset_Type_INT_MAX_SENTINEL_DO_NOT_USE_ =
      ::std::numeric_limits<::int32_t>::max(),
};

extern const uint32_t Dataset_Type_internal_data_[];
inline constexpr Dataset_Type Dataset_Type_Type_MIN =
    static_cast<Dataset_Type>(0);
inline constexpr Dataset_Type Dataset_Type_Type_MAX =
    static_cast<Dataset_Type>(1);
[[nodiscard]] inline bool Dataset_Type_IsValid(int value) {
  return 0 <= value && value <= 1;
}
inline constexpr int Dataset_Type_Type_ARRAYSIZE = 1 + 1;
[[nodiscard]] const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL
Dataset_Type_descriptor();
[[nodiscard]] inline auto ProtobufInternalGetEnumDescriptor(Dataset_Type) {
  return Dataset_Type_descriptor();
}
template <typename T>
[[nodiscard]] const ::std::string& Dataset_Type_Name(T value) {
  static_assert(::std::is_same<T, Dataset_Type>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to Type_Name().");
  return Dataset_Type_Name(static_cast<Dataset_Type>(value));
}
template <>
[[nodiscard]] inline const ::std::string& Dataset_Type_Name(Dataset_Type value) {
  return ::google::protobuf::internal::NameOfDenseEnum<Dataset_Type_descriptor, 0, 1>(
      static_cast<int>(value));
}
[[nodiscard]] inline bool Dataset_Type_Parse(
    ::absl::string_view name, Dataset_Type* PROTOBUF_NONNULL value) {
  return ::google::protobuf::internal::ParseNamedEnum<Dataset_Type>(Dataset_Type_descriptor(), name,
                                           value);
}
enum ErrorControl_Mode : int {
  ErrorControl_Mode_ABSOLUTE = 0,
  ErrorControl_Mode_RELATIVE = 1,
  ErrorControl_Mode_ErrorControl_Mode_INT_MIN_SENTINEL_DO_NOT_USE_ =
      ::std::numeric_limits<::int32_t>::min(),
  ErrorControl_Mode_ErrorControl_Mode_INT_MAX_SENTINEL_DO_NOT_USE_ =
      ::std::numeric_limits<::int32_t>::max(),
};

extern const uint32_t ErrorControl_Mode_internal_data_[];
inline constexpr ErrorControl_Mode ErrorControl_Mode_Mode_MIN =
    static_cast<ErrorControl_Mode>(0);
inline constexpr ErrorControl_Mode ErrorControl_Mode_Mode_MAX =
    static_cast<ErrorControl_Mode>(1);
[[nodiscard]] inline bool ErrorControl_Mode_IsValid(int value) {
  return 0 <= value && value <= 1;
}
inline constexpr int ErrorControl_Mode_Mode_ARRAYSIZE = 1 + 1;
[[nodiscard]] const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL
ErrorControl_Mode_descriptor();
[[nodiscard]] inline auto ProtobufInternalGetEnumDescriptor(ErrorControl_Mode) {
  return ErrorControl_Mode_descriptor();
}
template <typename T>
[[nodiscard]] const ::std::string& ErrorControl_Mode_Name(T value) {
  static_assert(::std::is_same<T, ErrorControl_Mode>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to Mode_Name().");
  return ErrorControl_Mode_Name(static_cast<ErrorControl_Mode>(value));
}
template <>
[[nodiscard]] inline const ::std::string& ErrorControl_Mode_Name(ErrorControl_Mode value) {
  return ::google::protobuf::internal::NameOfDenseEnum<ErrorControl_Mode_descriptor, 0, 1>(
      static_cast<int>(value));
}
[[nodiscard]] inline bool ErrorControl_Mode_Parse(
    ::absl::string_view name, ErrorControl_Mode* PROTOBUF_NONNULL value) {
  return ::google::protobuf::internal::ParseNamedEnum<ErrorControl_Mode>(ErrorControl_Mode_descriptor(), name,
                                           value);
}
enum ErrorControl_Norm : int {
  ErrorControl_Norm_L_INFINITY = 0,
  ErrorControl_Norm_S_NORM = 1,
  ErrorControl_Norm_ErrorControl_Norm_INT_MIN_SENTINEL_DO_NOT_USE_ =
      ::std::numeric_limits<::int32_t>::min(),
  ErrorControl_Norm_ErrorControl_Norm_INT_MAX_SENTINEL_DO_NOT_USE_ =
      ::std::numeric_limits<::int32_t>::max(),
};

extern const uint32_t ErrorControl_Norm_internal_data_[];
inline constexpr ErrorControl_Norm ErrorControl_Norm_Norm_MIN =
    static_cast<ErrorControl_Norm>(0);
inline constexpr ErrorControl_Norm ErrorControl_Norm_Norm_MAX =
    static_cast<ErrorControl_Norm>(1);
[[nodiscard]] inline bool ErrorControl_Norm_IsValid(int value) {
  return 0 <= value && value <= 1;
}
inline constexpr int ErrorControl_Norm_Norm_ARRAYSIZE = 1 + 1;
[[nodiscard]] const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL
ErrorControl_Norm_descriptor();
[[nodiscard]] inline auto ProtobufInternalGetEnumDescriptor(ErrorControl_Norm) {
  return ErrorControl_Norm_descriptor();
}
template <typename T>
[[nodiscard]] const ::std::string& ErrorControl_Norm_Name(T value) {
  static_assert(::std::is_same<T, ErrorControl_Norm>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to Norm_Name().");
  return ErrorControl_Norm_Name(static_cast<ErrorControl_Norm>(value));
}
template <>
[[nodiscard]] inline const ::std::string& ErrorControl_Norm_Name(ErrorControl_Norm value) {
  return ::google::protobuf::internal::NameOfDenseEnum<ErrorControl_Norm_descriptor, 0, 1>(
      static_cast<int>(value));
}
[[nodiscard]] inline bool ErrorControl_Norm_Parse(
    ::absl::string_view name, ErrorControl_Norm* PROTOBUF_NONNULL value) {
  return ::google::protobuf::internal::ParseNamedEnum<ErrorControl_Norm>(ErrorControl_Norm_descriptor(), name,
                                           value);
}
enum DomainDecomposition_Method : int {
  DomainDecomposition_Method_NOOP_METHOD = 0,
  DomainDecomposition_Method_MAX_DIMENSION = 1,
  DomainDecomposition_Method_BLOCK = 2,
  DomainDecomposition_Method_VARIABLE = 3,
  DomainDecomposition_Method_DomainDecomposition_Method_INT_MIN_SENTINEL_DO_NOT_USE_ =
      ::std::numeric_limits<::int32_t>::min(),
  DomainDecomposition_Method_DomainDecomposition_Method_INT_MAX_SENTINEL_DO_NOT_USE_ =
      ::std::numeric_limits<::int32_t>::max(),
};

extern const uint32_t DomainDecomposition_Method_internal_data_[];
inline constexpr DomainDecomposition_Method DomainDecomposition_Method_Method_MIN =
    static_cast<DomainDecomposition_Method>(0);
inline constexpr DomainDecomposition_Method DomainDecomposition_Method_Method_MAX =
    static_cast<DomainDecomposition_Method>(3);
[[nodiscard]] inline bool DomainDecomposition_Method_IsValid(int value) {
  return 0 <= value && value <= 3;
}
inline constexpr int DomainDecomposition_Method_Method_ARRAYSIZE = 3 + 1;
[[nodiscard]] const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL
DomainDecomposition_Method_descriptor();
[[nodiscard]] inline auto ProtobufInternalGetEnumDescriptor(DomainDecomposition_Method) {
  return DomainDecomposition_Method_descriptor();
}
template <typename T>
[[nodiscard]] const ::std::string& DomainDecomposition_Method_Name(T value) {
  static_assert(::std::is_same<T, DomainDecomposition_Method>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to Method_Name().");
  return DomainDecomposition_Method_Name(static_cast<DomainDecomposition_Method>(value));
}
template <>
[[nodiscard]] inline const ::std::string& DomainDecomposition_Method_Name(DomainDecomposition_Method value) {
  return ::google::protobuf::internal::NameOfDenseEnum<DomainDecomposition_Method_descriptor, 0, 3>(
      static_cast<int>(value));
}
[[nodiscard]] inline bool DomainDecomposition_Method_Parse(
    ::absl::string_view name, DomainDecomposition_Method* PROTOBUF_NONNULL value) {
  return ::google::protobuf::internal::ParseNamedEnum<DomainDecomposition_Method>(DomainDecomposition_Method_descriptor(), name,
                                           value);
}
enum FunctionDecomposition_Transform : int {
  FunctionDecomposition_Transform_MULTILEVEL_COEFFICIENTS = 0,
  FunctionDecomposition_Transform_FunctionDecomposition_Transform_INT_MIN_SENTINEL_DO_NOT_USE_ =
      ::std::numeric_limits<::int32_t>::min(),
  FunctionDecomposition_Transform_FunctionDecomposition_Transform_INT_MAX_SENTINEL_DO_NOT_USE_ =
      ::std::numeric_limits<::int32_t>::max(),
};

extern const uint32_t FunctionDecomposition_Transform_internal_data_[];
inline constexpr FunctionDecomposition_Transform FunctionDecomposition_Transform_Transform_MIN =
    static_cast<FunctionDecomposition_Transform>(0);
inline constexpr FunctionDecomposition_Transform FunctionDecomposition_Transform_Transform_MAX =
    static_cast<FunctionDecomposition_Transform>(0);
[[nodiscard]] inline bool FunctionDecomposition_Transform_IsValid(int value) {
  return 0 <= value && value <= 0;
}
inline constexpr int FunctionDecomposition_Transform_Transform_ARRAYSIZE = 0 + 1;
[[nodiscard]] const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL
FunctionDecomposition_Transform_descriptor();
[[nodiscard]] inline auto ProtobufInternalGetEnumDescriptor(FunctionDecomposition_Transform) {
  return FunctionDecomposition_Transform_descriptor();
}
template <typename T>
[[nodiscard]] const ::std::string& FunctionDecomposition_Transform_Name(T value) {
  static_assert(::std::is_same<T, FunctionDecomposition_Transform>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to Transform_Name().");
  return FunctionDecomposition_Transform_Name(static_cast<FunctionDecomposition_Transform>(value));
}
template <>
[[nodiscard]] inline const ::std::string& FunctionDecomposition_Transform_Name(FunctionDecomposition_Transform value) {
  return ::google::protobuf::internal::NameOfDenseEnum<FunctionDecomposition_Transform_descriptor, 0, 0>(
      static_cast<int>(value));
}
[[nodiscard]] inline bool FunctionDecomposition_Transform_Parse(
    ::absl::string_view name, FunctionDecomposition_Transform* PROTOBUF_NONNULL value) {
  return ::google::protobuf::internal::ParseNamedEnum<FunctionDecomposition_Transform>(FunctionDecomposition_Transform_descriptor(), name,
                                           value);
}
enum FunctionDecomposition_Hierarchy : int {
  FunctionDecomposition_Hierarchy_POWER_OF_TWO_PLUS_ONE = 0,
  FunctionDecomposition_Hierarchy_MULTIDIMENSION_WITH_GHOST_NODES = 1,
  FunctionDecomposition_Hierarchy_ONE_DIM_AT_A_TIME_WITH_GHOST_NODES = 2,
  FunctionDecomposition_Hierarchy_HYBRID_HIERARCHY = 3,
  FunctionDecomposition_Hierarchy_FunctionDecomposition_Hierarchy_INT_MIN_SENTINEL_DO_NOT_USE_ =
      ::std::numeric_limits<::int32_t>::min(),
  FunctionDecomposition_Hierarchy_FunctionDecomposition_Hierarchy_INT_MAX_SENTINEL_DO_NOT_USE_ =
      ::std::numeric_limits<::int32_t>::max(),
};

extern const uint32_t FunctionDecomposition_Hierarchy_internal_data_[];
inline constexpr FunctionDecomposition_Hierarchy FunctionDecomposition_Hierarchy_Hierarchy_MIN =
    static_cast<FunctionDecomposition_Hierarchy>(0);
inline constexpr FunctionDecomposition_Hierarchy FunctionDecomposition_Hierarchy_Hierarchy_MAX =
    static_cast<FunctionDecomposition_Hierarchy>(3);
[[nodiscard]] inline bool FunctionDecomposition_Hierarchy_IsValid(int value) {
  return 0 <= value && value <= 3;
}
inline constexpr int FunctionDecomposition_Hierarchy_Hierarchy_ARRAYSIZE = 3 + 1;
[[nodiscard]] const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL
FunctionDecomposition_Hierarchy_descriptor();
[[nodiscard]] inline auto ProtobufInternalGetEnumDescriptor(FunctionDecomposition_Hierarchy) {
  return FunctionDecomposition_Hierarchy_descriptor();
}
template <typename T>
[[nodiscard]] const ::std::string& FunctionDecomposition_Hierarchy_Name(T value) {
  static_assert(::std::is_same<T, FunctionDecomposition_Hierarchy>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to Hierarchy_Name().");
  return FunctionDecomposition_Hierarchy_Name(static_cast<FunctionDecomposition_Hierarchy>(value));
}
template <>
[[nodiscard]] inline const ::std::string& FunctionDecomposition_Hierarchy_Name(FunctionDecomposition_Hierarchy value) {
  return ::google::protobuf::internal::NameOfDenseEnum<FunctionDecomposition_Hierarchy_descriptor, 0, 3>(
      static_cast<int>(value));
}
[[nodiscard]] inline bool FunctionDecomposition_Hierarchy_Parse(
    ::absl::string_view name, FunctionDecomposition_Hierarchy* PROTOBUF_NONNULL value) {
  return ::google::protobuf::internal::ParseNamedEnum<FunctionDecomposition_Hierarchy>(FunctionDecomposition_Hierarchy_descriptor(), name,
                                           value);
}
enum Quantization_Method : int {
  Quantization_Method_NOOP_QUANTIZATION = 0,
  Quantization_Method_COEFFICIENTWISE_LINEAR = 1,
  Quantization_Method_Quantization_Method_INT_MIN_SENTINEL_DO_NOT_USE_ =
      ::std::numeric_limits<::int32_t>::min(),
  Quantization_Method_Quantization_Method_INT_MAX_SENTINEL_DO_NOT_USE_ =
      ::std::numeric_limits<::int32_t>::max(),
};

extern const uint32_t Quantization_Method_internal_data_[];
inline constexpr Quantization_Method Quantization_Method_Method_MIN =
    static_cast<Quantization_Method>(0);
inline constexpr Quantization_Method Quantization_Method_Method_MAX =
    static_cast<Quantization_Method>(1);
[[nodiscard]] inline bool Quantization_Method_IsValid(int value) {
  return 0 <= value && value <= 1;
}
inline constexpr int Quantization_Method_Method_ARRAYSIZE = 1 + 1;
[[nodiscard]] const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL
Quantization_Method_descriptor();
[[nodiscard]] inline auto ProtobufInternalGetEnumDescriptor(Quantization_Method) {
  return Quantization_Method_descriptor();
}
template <typename T>
[[nodiscard]] const ::std::string& Quantization_Method_Name(T value) {
  static_assert(::std::is_same<T, Quantization_Method>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to Method_Name().");
  return Quantization_Method_Name(static_cast<Quantization_Method>(value));
}
template <>
[[nodiscard]] inline const ::std::string& Quantization_Method_Name(Quantization_Method value) {
  return ::google::protobuf::internal::NameOfDenseEnum<Quantization_Method_descriptor, 0, 1>(
      static_cast<int>(value));
}
[[nodiscard]] inline bool Quantization_Method_Parse(
    ::absl::string_view name, Quantization_Method* PROTOBUF_NONNULL value) {
  return ::google::protobuf::internal::ParseNamedEnum<Quantization_Method>(Quantization_Method_descriptor(), name,
                                           value);
}
enum Quantization_BinWidths : int {
  Quantization_BinWidths_PER_COEFFICIENT = 0,
  Quantization_BinWidths_PER_LEVEL = 1,
  Quantization_BinWidths_Quantization_BinWidths_INT_MIN_SENTINEL_DO_NOT_USE_ =
      ::std::numeric_limits<::int32_t>::min(),
  Quantization_BinWidths_Quantization_BinWidths_INT_MAX_SENTINEL_DO_NOT_USE_ =
      ::std::numeric_limits<::int32_t>::max(),
};

extern const uint32_t Quantization_BinWidths_internal_data_[];
inline constexpr Quantization_BinWidths Quantization_BinWidths_BinWidths_MIN =
    static_cast<Quantization_BinWidths>(0);
inline constexpr Quantization_BinWidths Quantization_BinWidths_BinWidths_MAX =
    static_cast<Quantization_BinWidths>(1);
[[nodiscard]] inline bool Quantization_BinWidths_IsValid(int value) {
  return 0 <= value && value <= 1;
}
inline constexpr int Quantization_BinWidths_BinWidths_ARRAYSIZE = 1 + 1;
[[nodiscard]] const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL
Quantization_BinWidths_descriptor();
[[nodiscard]] inline auto ProtobufInternalGetEnumDescriptor(Quantization_BinWidths) {
  return Quantization_BinWidths_descriptor();
}
template <typename T>
[[nodiscard]] const ::std::string& Quantization_BinWidths_Name(T value) {
  static_assert(::std::is_same<T, Quantization_BinWidths>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to BinWidths_Name().");
  return Quantization_BinWidths_Name(static_cast<Quantization_BinWidths>(value));
}
template <>
[[nodiscard]] inline const ::std::string& Quantization_BinWidths_Name(Quantization_BinWidths value) {
  return ::google::protobuf::internal::NameOfDenseEnum<Quantization_BinWidths_descriptor, 0, 1>(
      static_cast<int>(value));
}
[[nodiscard]] inline bool Quantization_BinWidths_Parse(
    ::absl::string_view name, Quantization_BinWidths* PROTOBUF_NONNULL value) {
  return ::google::protobuf::internal::ParseNamedEnum<Quantization_BinWidths>(Quantization_BinWidths_descriptor(), name,
                                           value);
}
enum Quantization_Type : int {
  Quantization_Type_INT8_T = 0,
  Quantization_Type_INT16_T = 1,
  Quantization_Type_INT32_T = 2,
  Quantization_Type_INT64_T = 3,
  Quantization_Type_Quantization_Type_INT_MIN_SENTINEL_DO_NOT_USE_ =
      ::std::numeric_limits<::int32_t>::min(),
  Quantization_Type_Quantization_Type_INT_MAX_SENTINEL_DO_NOT_USE_ =
      ::std::numeric_limits<::int32_t>::max(),
};

extern const uint32_t Quantization_Type_internal_data_[];
inline constexpr Quantization_Type Quantization_Type_Type_MIN =
    static_cast<Quantization_Type>(0);
inline constexpr Quantization_Type Quantization_Type_Type_MAX =
    static_cast<Quantization_Type>(3);
[[nodiscard]] inline bool Quantization_Type_IsValid(int value) {
  return 0 <= value && value <= 3;
}
inline constexpr int Quantization_Type_Type_ARRAYSIZE = 3 + 1;
[[nodiscard]] const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL
Quantization_Type_descriptor();
[[nodiscard]] inline auto ProtobufInternalGetEnumDescriptor(Quantization_Type) {
  return Quantization_Type_descriptor();
}
template <typename T>
[[nodiscard]] const ::std::string& Quantization_Type_Name(T value) {
  static_assert(::std::is_same<T, Quantization_Type>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to Type_Name().");
  return Quantization_Type_Name(static_cast<Quantization_Type>(value));
}
template <>
[[nodiscard]] inline const ::std::string& Quantization_Type_Name(Quantization_Type value) {
  return ::google::protobuf::internal::NameOfDenseEnum<Quantization_Type_descriptor, 0, 3>(
      static_cast<int>(value));
}
[[nodiscard]] inline bool Quantization_Type_Parse(
    ::absl::string_view name, Quantization_Type* PROTOBUF_NONNULL value) {
  return ::google::protobuf::internal::ParseNamedEnum<Quantization_Type>(Quantization_Type_descriptor(), name,
                                           value);
}
enum BitplaneEncoding_Method : int {
  BitplaneEncoding_Method_NOOP_BITPLANE_ENCODING = 0,
  BitplaneEncoding_Method_GROUPED_BITPLANE_ENCODING = 1,
  BitplaneEncoding_Method_BitplaneEncoding_Method_INT_MIN_SENTINEL_DO_NOT_USE_ =
      ::std::numeric_limits<::int32_t>::min(),
  BitplaneEncoding_Method_BitplaneEncoding_Method_INT_MAX_SENTINEL_DO_NOT_USE_ =
      ::std::numeric_limits<::int32_t>::max(),
};

extern const uint32_t BitplaneEncoding_Method_internal_data_[];
inline constexpr BitplaneEncoding_Method BitplaneEncoding_Method_Method_MIN =
    static_cast<BitplaneEncoding_Method>(0);
inline constexpr BitplaneEncoding_Method BitplaneEncoding_Method_Method_MAX =
    static_cast<BitplaneEncoding_Method>(1);
[[nodiscard]] inline bool BitplaneEncoding_Method_IsValid(int value) {
  return 0 <= value && value <= 1;
}
inline constexpr int BitplaneEncoding_Method_Method_ARRAYSIZE = 1 + 1;
[[nodiscard]] const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL
BitplaneEncoding_Method_descriptor();
[[nodiscard]] inline auto ProtobufInternalGetEnumDescriptor(BitplaneEncoding_Method) {
  return BitplaneEncoding_Method_descriptor();
}
template <typename T>
[[nodiscard]] const ::std::string& BitplaneEncoding_Method_Name(T value) {
  static_assert(::std::is_same<T, BitplaneEncoding_Method>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to Method_Name().");
  return BitplaneEncoding_Method_Name(static_cast<BitplaneEncoding_Method>(value));
}
template <>
[[nodiscard]] inline const ::std::string& BitplaneEncoding_Method_Name(BitplaneEncoding_Method value) {
  return ::google::protobuf::internal::NameOfDenseEnum<BitplaneEncoding_Method_descriptor, 0, 1>(
      static_cast<int>(value));
}
[[nodiscard]] inline bool BitplaneEncoding_Method_Parse(
    ::absl::string_view name, BitplaneEncoding_Method* PROTOBUF_NONNULL value) {
  return ::google::protobuf::internal::ParseNamedEnum<BitplaneEncoding_Method>(BitplaneEncoding_Method_descriptor(), name,
                                           value);
}
enum BitplaneEncoding_Type : int {
  BitplaneEncoding_Type_INT8_T = 0,
  BitplaneEncoding_Type_INT16_T = 1,
  BitplaneEncoding_Type_INT32_T = 2,
  BitplaneEncoding_Type_INT64_T = 3,
  BitplaneEncoding_Type_BitplaneEncoding_Type_INT_MIN_SENTINEL_DO_NOT_USE_ =
      ::std::numeric_limits<::int32_t>::min(),
  BitplaneEncoding_Type_BitplaneEncoding_Type_INT_MAX_SENTINEL_DO_NOT_USE_ =
      ::std::numeric_limits<::int32_t>::max(),
};

extern const uint32_t BitplaneEncoding_Type_internal_data_[];
inline constexpr BitplaneEncoding_Type BitplaneEncoding_Type_Type_MIN =
    static_cast<BitplaneEncoding_Type>(0);
inline constexpr BitplaneEncoding_Type BitplaneEncoding_Type_Type_MAX =
    static_cast<BitplaneEncoding_Type>(3);
[[nodiscard]] inline bool BitplaneEncoding_Type_IsValid(int value) {
  return 0 <= value && value <= 3;
}
inline constexpr int BitplaneEncoding_Type_Type_ARRAYSIZE = 3 + 1;
[[nodiscard]] const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL
BitplaneEncoding_Type_descriptor();
[[nodiscard]] inline auto ProtobufInternalGetEnumDescriptor(BitplaneEncoding_Type) {
  return BitplaneEncoding_Type_descriptor();
}
template <typename T>
[[nodiscard]] const ::std::string& BitplaneEncoding_Type_Name(T value) {
  static_assert(::std::is_same<T, BitplaneEncoding_Type>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to Type_Name().");
  return BitplaneEncoding_Type_Name(static_cast<BitplaneEncoding_Type>(value));
}
template <>
[[nodiscard]] inline const ::std::string& BitplaneEncoding_Type_Name(BitplaneEncoding_Type value) {
  return ::google::protobuf::internal::NameOfDenseEnum<BitplaneEncoding_Type_descriptor, 0, 3>(
      static_cast<int>(value));
}
[[nodiscard]] inline bool BitplaneEncoding_Type_Parse(
    ::absl::string_view name, BitplaneEncoding_Type* PROTOBUF_NONNULL value) {
  return ::google::protobuf::internal::ParseNamedEnum<BitplaneEncoding_Type>(BitplaneEncoding_Type_descriptor(), name,
                                           value);
}
enum Encoding_Preprocessor : int {
  Encoding_Preprocessor_NOOP_PREPROCESSOR = 0,
  Encoding_Preprocessor_SHUFFLE = 1,
  Encoding_Preprocessor_Encoding_Preprocessor_INT_MIN_SENTINEL_DO_NOT_USE_ =
      ::std::numeric_limits<::int32_t>::min(),
  Encoding_Preprocessor_Encoding_Preprocessor_INT_MAX_SENTINEL_DO_NOT_USE_ =
      ::std::numeric_limits<::int32_t>::max(),
};

extern const uint32_t Encoding_Preprocessor_internal_data_[];
inline constexpr Encoding_Preprocessor Encoding_Preprocessor_Preprocessor_MIN =
    static_cast<Encoding_Preprocessor>(0);
inline constexpr Encoding_Preprocessor Encoding_Preprocessor_Preprocessor_MAX =
    static_cast<Encoding_Preprocessor>(1);
[[nodiscard]] inline bool Encoding_Preprocessor_IsValid(int value) {
  return 0 <= value && value <= 1;
}
inline constexpr int Encoding_Preprocessor_Preprocessor_ARRAYSIZE = 1 + 1;
[[nodiscard]] const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL
Encoding_Preprocessor_descriptor();
[[nodiscard]] inline auto ProtobufInternalGetEnumDescriptor(Encoding_Preprocessor) {
  return Encoding_Preprocessor_descriptor();
}
template <typename T>
[[nodiscard]] const ::std::string& Encoding_Preprocessor_Name(T value) {
  static_assert(::std::is_same<T, Encoding_Preprocessor>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to Preprocessor_Name().");
  return Encoding_Preprocessor_Name(static_cast<Encoding_Preprocessor>(value));
}
template <>
[[nodiscard]] inline const ::std::string& Encoding_Preprocessor_Name(Encoding_Preprocessor value) {
  return ::google::protobuf::internal::NameOfDenseEnum<Encoding_Preprocessor_descriptor, 0, 1>(
      static_cast<int>(value));
}
[[nodiscard]] inline bool Encoding_Preprocessor_Parse(
    ::absl::string_view name, Encoding_Preprocessor* PROTOBUF_NONNULL value) {
  return ::google::protobuf::internal::ParseNamedEnum<Encoding_Preprocessor>(Encoding_Preprocessor_descriptor(), name,
                                           value);
}
enum Encoding_Compressor : int {
  Encoding_Compressor_NOOP_COMPRESSOR = 0,
  Encoding_Compressor_CPU_HUFFMAN_ZLIB = 1,
  Encoding_Compressor_CPU_HUFFMAN_ZSTD = 2,
  Encoding_Compressor_X_HUFFMAN = 3,
  Encoding_Compressor_X_HUFFMAN_LZ4 = 4,
  Encoding_Compressor_X_HUFFMAN_ZSTD = 5,
  Encoding_Compressor_Encoding_Compressor_INT_MIN_SENTINEL_DO_NOT_USE_ =
      ::std::numeric_limits<::int32_t>::min(),
  Encoding_Compressor_Encoding_Compressor_INT_MAX_SENTINEL_DO_NOT_USE_ =
      ::std::numeric_limits<::int32_t>::max(),
};

extern const uint32_t Encoding_Compressor_internal_data_[];
inline constexpr Encoding_Compressor Encoding_Compressor_Compressor_MIN =
    static_cast<Encoding_Compressor>(0);
inline constexpr Encoding_Compressor Encoding_Compressor_Compressor_MAX =
    static_cast<Encoding_Compressor>(5);
[[nodiscard]] inline bool Encoding_Compressor_IsValid(int value) {
  return 0 <= value && value <= 5;
}
inline constexpr int Encoding_Compressor_Compressor_ARRAYSIZE = 5 + 1;
[[nodiscard]] const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL
Encoding_Compressor_descriptor();
[[nodiscard]] inline auto ProtobufInternalGetEnumDescriptor(Encoding_Compressor) {
  return Encoding_Compressor_descriptor();
}
template <typename T>
[[nodiscard]] const ::std::string& Encoding_Compressor_Name(T value) {
  static_assert(::std::is_same<T, Encoding_Compressor>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to Compressor_Name().");
  return Encoding_Compressor_Name(static_cast<Encoding_Compressor>(value));
}
template <>
[[nodiscard]] inline const ::std::string& Encoding_Compressor_Name(Encoding_Compressor value) {
  return ::google::protobuf::internal::NameOfDenseEnum<Encoding_Compressor_descriptor, 0, 5>(
      static_cast<int>(value));
}
[[nodiscard]] inline bool Encoding_Compressor_Parse(
    ::absl::string_view name, Encoding_Compressor* PROTOBUF_NONNULL value) {
  return ::google::protobuf::internal::ParseNamedEnum<Encoding_Compressor>(Encoding_Compressor_descriptor(), name,
                                           value);
}
enum Device_Backend : int {
  Device_Backend_CPU = 0,
  Device_Backend_X_SERIAL = 1,
  Device_Backend_X_OPENMP = 2,
  Device_Backend_X_CUDA = 3,
  Device_Backend_X_HIP = 4,
  Device_Backend_X_SYCL = 5,
  Device_Backend_Device_Backend_INT_MIN_SENTINEL_DO_NOT_USE_ =
      ::std::numeric_limits<::int32_t>::min(),
  Device_Backend_Device_Backend_INT_MAX_SENTINEL_DO_NOT_USE_ =
      ::std::numeric_limits<::int32_t>::max(),
};

extern const uint32_t Device_Backend_internal_data_[];
inline constexpr Device_Backend Device_Backend_Backend_MIN =
    static_cast<Device_Backend>(0);
inline constexpr Device_Backend Device_Backend_Backend_MAX =
    static_cast<Device_Backend>(5);
[[nodiscard]] inline bool Device_Backend_IsValid(int value) {
  return 0 <= value && value <= 5;
}
inline constexpr int Device_Backend_Backend_ARRAYSIZE = 5 + 1;
[[nodiscard]] const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL
Device_Backend_descriptor();
[[nodiscard]] inline auto ProtobufInternalGetEnumDescriptor(Device_Backend) {
  return Device_Backend_descriptor();
}
template <typename T>
[[nodiscard]] const ::std::string& Device_Backend_Name(T value) {
  static_assert(::std::is_same<T, Device_Backend>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to Backend_Name().");
  return Device_Backend_Name(static_cast<Device_Backend>(value));
}
template <>
[[nodiscard]] inline const ::std::string& Device_Backend_Name(Device_Backend value) {
  return ::google::protobuf::internal::NameOfDenseEnum<Device_Backend_descriptor, 0, 5>(
      static_cast<int>(value));
}
[[nodiscard]] inline bool Device_Backend_Parse(
    ::absl::string_view name, Device_Backend* PROTOBUF_NONNULL value) {
  return ::google::protobuf::internal::ParseNamedEnum<Device_Backend>(Device_Backend_descriptor(), name,
                                           value);
}
using ::google::protobuf::internal::generated_enum::AbslParseFlag;
using ::google::protobuf::internal::generated_enum::AbslUnparseFlag;

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


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

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED VersionNumber final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:mgard.pb.VersionNumber) */ {
  using Super_ = ::google::protobuf::Message;

 public:
  inline VersionNumber() : VersionNumber(nullptr) {}
  ~VersionNumber() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(VersionNumber* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(VersionNumber));
  }
#endif

  template <typename = void>
  explicit constexpr VersionNumber(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline VersionNumber(const VersionNumber& from) : VersionNumber(nullptr, from) {}
  inline VersionNumber(VersionNumber&& from) noexcept : VersionNumber(nullptr, ::std::move(from)) {}
  inline VersionNumber& operator=(const VersionNumber& from) {
    CopyFrom(from);
    return *this;
  }
  inline VersionNumber& operator=(VersionNumber&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  [[nodiscard]] inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const VersionNumber& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<VersionNumber>(&VersionNumber_globals_);
  }
  static constexpr int kIndexInFileMessages = 0;
  friend void swap(VersionNumber& a, VersionNumber& b) { a.Swap(&b); }
  inline void Swap(VersionNumber* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(VersionNumber* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] VersionNumber* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<VersionNumber>(arena);
  }
  using Super_::CopyFrom;
  void CopyFrom(const VersionNumber& from);
  using Super_::MergeFrom;
  void MergeFrom(const VersionNumber& from) { VersionNumber::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(VersionNumber* PROTOBUF_NONNULL other);
 private:
  static ::absl::string_view FullMessageName() { return "mgard.pb.VersionNumber"; }

  explicit VersionNumber(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  VersionNumber(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const VersionNumber& from);
  VersionNumber(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, VersionNumber&& from) noexcept
      : VersionNumber(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kMajorFieldNumber = 1,
    kMinorFieldNumber = 2,
    kPatchFieldNumber = 3,
  };
  // uint64 major_ = 1;
  void clear_major_() ;
  [[nodiscard]] ::uint64_t major_() const;
  void set_major_(::uint64_t value);

  private:
  ::uint64_t _internal_major_() const;
  void _internal_set_major_(::uint64_t value);

  public:
  // uint64 minor_ = 2;
  void clear_minor_() ;
  [[nodiscard]] ::uint64_t minor_() const;
  void set_minor_(::uint64_t value);

  private:
  ::uint64_t _internal_minor_() const;
  void _internal_set_minor_(::uint64_t value);

  public:
  // uint64 patch_ = 3;
  void clear_patch_() ;
  [[nodiscard]] ::uint64_t patch_() const;
  void set_patch_(::uint64_t value);

  private:
  ::uint64_t _internal_patch_() const;
  void _internal_set_patch_(::uint64_t value);

  public:
  // @@protoc_insertion_point(class_scope:mgard.pb.VersionNumber)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<2, 3,
                          0, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const VersionNumber& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::uint64_t major__;
    ::uint64_t minor__;
    ::uint64_t patch__;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_mgard_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED Quantization final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:mgard.pb.Quantization) */ {
  using Super_ = ::google::protobuf::Message;

 public:
  inline Quantization() : Quantization(nullptr) {}
  ~Quantization() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(Quantization* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(Quantization));
  }
#endif

  template <typename = void>
  explicit constexpr Quantization(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline Quantization(const Quantization& from) : Quantization(nullptr, from) {}
  inline Quantization(Quantization&& from) noexcept : Quantization(nullptr, ::std::move(from)) {}
  inline Quantization& operator=(const Quantization& from) {
    CopyFrom(from);
    return *this;
  }
  inline Quantization& operator=(Quantization&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  [[nodiscard]] inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const Quantization& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<Quantization>(&Quantization_globals_);
  }
  static constexpr int kIndexInFileMessages = 8;
  friend void swap(Quantization& a, Quantization& b) { a.Swap(&b); }
  inline void Swap(Quantization* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Quantization* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] Quantization* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<Quantization>(arena);
  }
  using Super_::CopyFrom;
  void CopyFrom(const Quantization& from);
  using Super_::MergeFrom;
  void MergeFrom(const Quantization& from) { Quantization::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(Quantization* PROTOBUF_NONNULL other);
 private:
  static ::absl::string_view FullMessageName() { return "mgard.pb.Quantization"; }

  explicit Quantization(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  Quantization(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Quantization& from);
  Quantization(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, Quantization&& from) noexcept
      : Quantization(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------
  using Method = Quantization_Method;
  static constexpr Method NOOP_QUANTIZATION = Quantization_Method_NOOP_QUANTIZATION;
  static constexpr Method COEFFICIENTWISE_LINEAR = Quantization_Method_COEFFICIENTWISE_LINEAR;
  [[nodiscard]] static inline bool Method_IsValid(int value) {
    return Quantization_Method_IsValid(value);
  }
  static constexpr Method Method_MIN = Quantization_Method_Method_MIN;
  static constexpr Method Method_MAX = Quantization_Method_Method_MAX;
  static constexpr int Method_ARRAYSIZE = Quantization_Method_Method_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL Method_descriptor() {
    return Quantization_Method_descriptor();
  }
  template <typename T>
  [[nodiscard]] static inline const ::std::string& Method_Name(T value) {
    return Quantization_Method_Name(value);
  }
  [[nodiscard]] static inline bool Method_Parse(
      ::absl::string_view name, Method* PROTOBUF_NONNULL value) {
    return Quantization_Method_Parse(name, value);
  }
  using BinWidths = Quantization_BinWidths;
  static constexpr BinWidths PER_COEFFICIENT = Quantization_BinWidths_PER_COEFFICIENT;
  static constexpr BinWidths PER_LEVEL = Quantization_BinWidths_PER_LEVEL;
  [[nodiscard]] static inline bool BinWidths_IsValid(int value) {
    return Quantization_BinWidths_IsValid(value);
  }
  static constexpr BinWidths BinWidths_MIN = Quantization_BinWidths_BinWidths_MIN;
  static constexpr BinWidths BinWidths_MAX = Quantization_BinWidths_BinWidths_MAX;
  static constexpr int BinWidths_ARRAYSIZE = Quantization_BinWidths_BinWidths_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL BinWidths_descriptor() {
    return Quantization_BinWidths_descriptor();
  }
  template <typename T>
  [[nodiscard]] static inline const ::std::string& BinWidths_Name(T value) {
    return Quantization_BinWidths_Name(value);
  }
  [[nodiscard]] static inline bool BinWidths_Parse(
      ::absl::string_view name, BinWidths* PROTOBUF_NONNULL value) {
    return Quantization_BinWidths_Parse(name, value);
  }
  using Type = Quantization_Type;
  static constexpr Type INT8_T = Quantization_Type_INT8_T;
  static constexpr Type INT16_T = Quantization_Type_INT16_T;
  static constexpr Type INT32_T = Quantization_Type_INT32_T;
  static constexpr Type INT64_T = Quantization_Type_INT64_T;
  [[nodiscard]] static inline bool Type_IsValid(int value) {
    return Quantization_Type_IsValid(value);
  }
  static constexpr Type Type_MIN = Quantization_Type_Type_MIN;
  static constexpr Type Type_MAX = Quantization_Type_Type_MAX;
  static constexpr int Type_ARRAYSIZE = Quantization_Type_Type_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL Type_descriptor() {
    return Quantization_Type_descriptor();
  }
  template <typename T>
  [[nodiscard]] static inline const ::std::string& Type_Name(T value) {
    return Quantization_Type_Name(value);
  }
  [[nodiscard]] static inline bool Type_Parse(
      ::absl::string_view name, Type* PROTOBUF_NONNULL value) {
    return Quantization_Type_Parse(name, value);
  }

  // accessors -------------------------------------------------------
  enum : int {
    kMethodFieldNumber = 1,
    kBinWidthsFieldNumber = 2,
    kTypeFieldNumber = 3,
    kBigEndianFieldNumber = 4,
  };
  // .mgard.pb.Quantization.Method method = 1;
  void clear_method() ;
  [[nodiscard]] ::mgard::pb::Quantization_Method method() const;
  void set_method(::mgard::pb::Quantization_Method value);

  private:
  ::mgard::pb::Quantization_Method _internal_method() const;
  void _internal_set_method(::mgard::pb::Quantization_Method value);

  public:
  // .mgard.pb.Quantization.BinWidths bin_widths = 2;
  void clear_bin_widths() ;
  [[nodiscard]] ::mgard::pb::Quantization_BinWidths bin_widths() const;
  void set_bin_widths(::mgard::pb::Quantization_BinWidths value);

  private:
  ::mgard::pb::Quantization_BinWidths _internal_bin_widths() const;
  void _internal_set_bin_widths(::mgard::pb::Quantization_BinWidths value);

  public:
  // .mgard.pb.Quantization.Type type = 3;
  void clear_type() ;
  [[nodiscard]] ::mgard::pb::Quantization_Type type() const;
  void set_type(::mgard::pb::Quantization_Type value);

  private:
  ::mgard::pb::Quantization_Type _internal_type() const;
  void _internal_set_type(::mgard::pb::Quantization_Type value);

  public:
  // bool big_endian = 4;
  void clear_big_endian() ;
  [[nodiscard]] bool big_endian() const;
  void set_big_endian(bool value);

  private:
  bool _internal_big_endian() const;
  void _internal_set_big_endian(bool value);

  public:
  // @@protoc_insertion_point(class_scope:mgard.pb.Quantization)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<2, 4,
                          0, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const Quantization& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    int method_;
    int bin_widths_;
    int type_;
    bool big_endian_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_mgard_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED FunctionDecomposition final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:mgard.pb.FunctionDecomposition) */ {
  using Super_ = ::google::protobuf::Message;

 public:
  inline FunctionDecomposition() : FunctionDecomposition(nullptr) {}
  ~FunctionDecomposition() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(FunctionDecomposition* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(FunctionDecomposition));
  }
#endif

  template <typename = void>
  explicit constexpr FunctionDecomposition(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline FunctionDecomposition(const FunctionDecomposition& from) : FunctionDecomposition(nullptr, from) {}
  inline FunctionDecomposition(FunctionDecomposition&& from) noexcept : FunctionDecomposition(nullptr, ::std::move(from)) {}
  inline FunctionDecomposition& operator=(const FunctionDecomposition& from) {
    CopyFrom(from);
    return *this;
  }
  inline FunctionDecomposition& operator=(FunctionDecomposition&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  [[nodiscard]] inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const FunctionDecomposition& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<FunctionDecomposition>(&FunctionDecomposition_globals_);
  }
  static constexpr int kIndexInFileMessages = 7;
  friend void swap(FunctionDecomposition& a, FunctionDecomposition& b) { a.Swap(&b); }
  inline void Swap(FunctionDecomposition* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(FunctionDecomposition* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] FunctionDecomposition* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<FunctionDecomposition>(arena);
  }
  using Super_::CopyFrom;
  void CopyFrom(const FunctionDecomposition& from);
  using Super_::MergeFrom;
  void MergeFrom(const FunctionDecomposition& from) { FunctionDecomposition::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(FunctionDecomposition* PROTOBUF_NONNULL other);
 private:
  static ::absl::string_view FullMessageName() { return "mgard.pb.FunctionDecomposition"; }

  explicit FunctionDecomposition(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  FunctionDecomposition(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const FunctionDecomposition& from);
  FunctionDecomposition(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, FunctionDecomposition&& from) noexcept
      : FunctionDecomposition(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------
  using Transform = FunctionDecomposition_Transform;
  static constexpr Transform MULTILEVEL_COEFFICIENTS = FunctionDecomposition_Transform_MULTILEVEL_COEFFICIENTS;
  [[nodiscard]] static inline bool Transform_IsValid(int value) {
    return FunctionDecomposition_Transform_IsValid(value);
  }
  static constexpr Transform Transform_MIN = FunctionDecomposition_Transform_Transform_MIN;
  static constexpr Transform Transform_MAX = FunctionDecomposition_Transform_Transform_MAX;
  static constexpr int Transform_ARRAYSIZE = FunctionDecomposition_Transform_Transform_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL Transform_descriptor() {
    return FunctionDecomposition_Transform_descriptor();
  }
  template <typename T>
  [[nodiscard]] static inline const ::std::string& Transform_Name(T value) {
    return FunctionDecomposition_Transform_Name(value);
  }
  [[nodiscard]] static inline bool Transform_Parse(
      ::absl::string_view name, Transform* PROTOBUF_NONNULL value) {
    return FunctionDecomposition_Transform_Parse(name, value);
  }
  using Hierarchy = FunctionDecomposition_Hierarchy;
  static constexpr Hierarchy POWER_OF_TWO_PLUS_ONE = FunctionDecomposition_Hierarchy_POWER_OF_TWO_PLUS_ONE;
  static constexpr Hierarchy MULTIDIMENSION_WITH_GHOST_NODES = FunctionDecomposition_Hierarchy_MULTIDIMENSION_WITH_GHOST_NODES;
  static constexpr Hierarchy ONE_DIM_AT_A_TIME_WITH_GHOST_NODES = FunctionDecomposition_Hierarchy_ONE_DIM_AT_A_TIME_WITH_GHOST_NODES;
  static constexpr Hierarchy HYBRID_HIERARCHY = FunctionDecomposition_Hierarchy_HYBRID_HIERARCHY;
  [[nodiscard]] static inline bool Hierarchy_IsValid(int value) {
    return FunctionDecomposition_Hierarchy_IsValid(value);
  }
  static constexpr Hierarchy Hierarchy_MIN = FunctionDecomposition_Hierarchy_Hierarchy_MIN;
  static constexpr Hierarchy Hierarchy_MAX = FunctionDecomposition_Hierarchy_Hierarchy_MAX;
  static constexpr int Hierarchy_ARRAYSIZE = FunctionDecomposition_Hierarchy_Hierarchy_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL Hierarchy_descriptor() {
    return FunctionDecomposition_Hierarchy_descriptor();
  }
  template <typename T>
  [[nodiscard]] static inline const ::std::string& Hierarchy_Name(T value) {
    return FunctionDecomposition_Hierarchy_Name(value);
  }
  [[nodiscard]] static inline bool Hierarchy_Parse(
      ::absl::string_view name, Hierarchy* PROTOBUF_NONNULL value) {
    return FunctionDecomposition_Hierarchy_Parse(name, value);
  }

  // accessors -------------------------------------------------------
  enum : int {
    kTransformFieldNumber = 1,
    kHierarchyFieldNumber = 2,
    kLTargetFieldNumber = 3,
  };
  // .mgard.pb.FunctionDecomposition.Transform transform = 1;
  void clear_transform() ;
  [[nodiscard]] ::mgard::pb::FunctionDecomposition_Transform transform() const;
  void set_transform(::mgard::pb::FunctionDecomposition_Transform value);

  private:
  ::mgard::pb::FunctionDecomposition_Transform _internal_transform() const;
  void _internal_set_transform(::mgard::pb::FunctionDecomposition_Transform value);

  public:
  // .mgard.pb.FunctionDecomposition.Hierarchy hierarchy = 2;
  void clear_hierarchy() ;
  [[nodiscard]] ::mgard::pb::FunctionDecomposition_Hierarchy hierarchy() const;
  void set_hierarchy(::mgard::pb::FunctionDecomposition_Hierarchy value);

  private:
  ::mgard::pb::FunctionDecomposition_Hierarchy _internal_hierarchy() const;
  void _internal_set_hierarchy(::mgard::pb::FunctionDecomposition_Hierarchy value);

  public:
  // uint64 L_target = 3;
  void clear_l_target() ;
  [[nodiscard]] ::uint64_t l_target() const;
  void set_l_target(::uint64_t value);

  private:
  ::uint64_t _internal_l_target() const;
  void _internal_set_l_target(::uint64_t value);

  public:
  // @@protoc_insertion_point(class_scope:mgard.pb.FunctionDecomposition)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<2, 3,
                          0, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const FunctionDecomposition& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    int transform_;
    int hierarchy_;
    ::uint64_t l_target_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_mgard_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED ExplicitCubeGeometry final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:mgard.pb.ExplicitCubeGeometry) */ {
  using Super_ = ::google::protobuf::Message;

 public:
  inline ExplicitCubeGeometry() : ExplicitCubeGeometry(nullptr) {}
  ~ExplicitCubeGeometry() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(ExplicitCubeGeometry* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(ExplicitCubeGeometry));
  }
#endif

  template <typename = void>
  explicit constexpr ExplicitCubeGeometry(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline ExplicitCubeGeometry(const ExplicitCubeGeometry& from) : ExplicitCubeGeometry(nullptr, from) {}
  inline ExplicitCubeGeometry(ExplicitCubeGeometry&& from) noexcept : ExplicitCubeGeometry(nullptr, ::std::move(from)) {}
  inline ExplicitCubeGeometry& operator=(const ExplicitCubeGeometry& from) {
    CopyFrom(from);
    return *this;
  }
  inline ExplicitCubeGeometry& operator=(ExplicitCubeGeometry&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  [[nodiscard]] inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const ExplicitCubeGeometry& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<ExplicitCubeGeometry>(&ExplicitCubeGeometry_globals_);
  }
  static constexpr int kIndexInFileMessages = 2;
  friend void swap(ExplicitCubeGeometry& a, ExplicitCubeGeometry& b) { a.Swap(&b); }
  inline void Swap(ExplicitCubeGeometry* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ExplicitCubeGeometry* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] ExplicitCubeGeometry* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<ExplicitCubeGeometry>(arena);
  }
  using Super_::CopyFrom;
  void CopyFrom(const ExplicitCubeGeometry& from);
  using Super_::MergeFrom;
  void MergeFrom(const ExplicitCubeGeometry& from) { ExplicitCubeGeometry::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(ExplicitCubeGeometry* PROTOBUF_NONNULL other);
 private:
  static ::absl::string_view FullMessageName() { return "mgard.pb.ExplicitCubeGeometry"; }

  explicit ExplicitCubeGeometry(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  ExplicitCubeGeometry(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ExplicitCubeGeometry& from);
  ExplicitCubeGeometry(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, ExplicitCubeGeometry&& from) noexcept
      : ExplicitCubeGeometry(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kCoordinatesFieldNumber = 2,
  };
  // repeated double coordinates = 2;
  [[nodiscard]] int coordinates_size() const;
  private:
  int _internal_coordinates_size() const;

  public:
  void clear_coordinates() ;
  [[nodiscard]] double coordinates(int index) const;
  void set_coordinates(int index, double value);
  void add_coordinates(double value);
  [[nodiscard]] const ::google::protobuf::RepeatedField<double>& coordinates()
      const;
  ::google::protobuf::RepeatedField<double>* PROTOBUF_NONNULL mutable_coordinates();

  private:
  const ::google::protobuf::RepeatedField<double>& _internal_coordinates() const;
  ::google::protobuf::RepeatedField<double>* PROTOBUF_NONNULL _internal_mutable_coordinates();

  public:
  // @@protoc_insertion_point(class_scope:mgard.pb.ExplicitCubeGeometry)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<0, 1,
                          0, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const ExplicitCubeGeometry& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedField<double> coordinates_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_mgard_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED ErrorControl final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:mgard.pb.ErrorControl) */ {
  using Super_ = ::google::protobuf::Message;

 public:
  inline ErrorControl() : ErrorControl(nullptr) {}
  ~ErrorControl() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(ErrorControl* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(ErrorControl));
  }
#endif

  template <typename = void>
  explicit constexpr ErrorControl(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline ErrorControl(const ErrorControl& from) : ErrorControl(nullptr, from) {}
  inline ErrorControl(ErrorControl&& from) noexcept : ErrorControl(nullptr, ::std::move(from)) {}
  inline ErrorControl& operator=(const ErrorControl& from) {
    CopyFrom(from);
    return *this;
  }
  inline ErrorControl& operator=(ErrorControl&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  [[nodiscard]] inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const ErrorControl& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<ErrorControl>(&ErrorControl_globals_);
  }
  static constexpr int kIndexInFileMessages = 5;
  friend void swap(ErrorControl& a, ErrorControl& b) { a.Swap(&b); }
  inline void Swap(ErrorControl* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ErrorControl* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] ErrorControl* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<ErrorControl>(arena);
  }
  using Super_::CopyFrom;
  void CopyFrom(const ErrorControl& from);
  using Super_::MergeFrom;
  void MergeFrom(const ErrorControl& from) { ErrorControl::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(ErrorControl* PROTOBUF_NONNULL other);
 private:
  static ::absl::string_view FullMessageName() { return "mgard.pb.ErrorControl"; }

  explicit ErrorControl(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  ErrorControl(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ErrorControl& from);
  ErrorControl(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, ErrorControl&& from) noexcept
      : ErrorControl(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------
  using Mode = ErrorControl_Mode;
  static constexpr Mode ABSOLUTE = ErrorControl_Mode_ABSOLUTE;
  static constexpr Mode RELATIVE = ErrorControl_Mode_RELATIVE;
  [[nodiscard]] static inline bool Mode_IsValid(int value) {
    return ErrorControl_Mode_IsValid(value);
  }
  static constexpr Mode Mode_MIN = ErrorControl_Mode_Mode_MIN;
  static constexpr Mode Mode_MAX = ErrorControl_Mode_Mode_MAX;
  static constexpr int Mode_ARRAYSIZE = ErrorControl_Mode_Mode_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL Mode_descriptor() {
    return ErrorControl_Mode_descriptor();
  }
  template <typename T>
  [[nodiscard]] static inline const ::std::string& Mode_Name(T value) {
    return ErrorControl_Mode_Name(value);
  }
  [[nodiscard]] static inline bool Mode_Parse(
      ::absl::string_view name, Mode* PROTOBUF_NONNULL value) {
    return ErrorControl_Mode_Parse(name, value);
  }
  using Norm = ErrorControl_Norm;
  static constexpr Norm L_INFINITY = ErrorControl_Norm_L_INFINITY;
  static constexpr Norm S_NORM = ErrorControl_Norm_S_NORM;
  [[nodiscard]] static inline bool Norm_IsValid(int value) {
    return ErrorControl_Norm_IsValid(value);
  }
  static constexpr Norm Norm_MIN = ErrorControl_Norm_Norm_MIN;
  static constexpr Norm Norm_MAX = ErrorControl_Norm_Norm_MAX;
  static constexpr int Norm_ARRAYSIZE = ErrorControl_Norm_Norm_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL Norm_descriptor() {
    return ErrorControl_Norm_descriptor();
  }
  template <typename T>
  [[nodiscard]] static inline const ::std::string& Norm_Name(T value) {
    return ErrorControl_Norm_Name(value);
  }
  [[nodiscard]] static inline bool Norm_Parse(
      ::absl::string_view name, Norm* PROTOBUF_NONNULL value) {
    return ErrorControl_Norm_Parse(name, value);
  }

  // accessors -------------------------------------------------------
  enum : int {
    kModeFieldNumber = 1,
    kNormFieldNumber = 2,
    kSFieldNumber = 3,
    kNormOfOriginalDataFieldNumber = 4,
    kToleranceFieldNumber = 5,
  };
  // .mgard.pb.ErrorControl.Mode mode = 1;
  void clear_mode() ;
  [[nodiscard]] ::mgard::pb::ErrorControl_Mode mode() const;
  void set_mode(::mgard::pb::ErrorControl_Mode value);

  private:
  ::mgard::pb::ErrorControl_Mode _internal_mode() const;
  void _internal_set_mode(::mgard::pb::ErrorControl_Mode value);

  public:
  // .mgard.pb.ErrorControl.Norm norm = 2;
  void clear_norm() ;
  [[nodiscard]] ::mgard::pb::ErrorControl_Norm norm() const;
  void set_norm(::mgard::pb::ErrorControl_Norm value);

  private:
  ::mgard::pb::ErrorControl_Norm _internal_norm() const;
  void _internal_set_norm(::mgard::pb::ErrorControl_Norm value);

  public:
  // double s = 3;
  void clear_s() ;
  [[nodiscard]] double s() const;
  void set_s(double value);

  private:
  double _internal_s() const;
  void _internal_set_s(double value);

  public:
  // double norm_of_original_data = 4;
  void clear_norm_of_original_data() ;
  [[nodiscard]] double norm_of_original_data() const;
  void set_norm_of_original_data(double value);

  private:
  double _internal_norm_of_original_data() const;
  void _internal_set_norm_of_original_data(double value);

  public:
  // double tolerance = 5;
  void clear_tolerance() ;
  [[nodiscard]] double tolerance() const;
  void set_tolerance(double value);

  private:
  double _internal_tolerance() const;
  void _internal_set_tolerance(double value);

  public:
  // @@protoc_insertion_point(class_scope:mgard.pb.ErrorControl)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<3, 5,
                          0, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const ErrorControl& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    int mode_;
    int norm_;
    double s_;
    double norm_of_original_data_;
    double tolerance_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_mgard_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED Encoding final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:mgard.pb.Encoding) */ {
  using Super_ = ::google::protobuf::Message;

 public:
  inline Encoding() : Encoding(nullptr) {}
  ~Encoding() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(Encoding* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(Encoding));
  }
#endif

  template <typename = void>
  explicit constexpr Encoding(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline Encoding(const Encoding& from) : Encoding(nullptr, from) {}
  inline Encoding(Encoding&& from) noexcept : Encoding(nullptr, ::std::move(from)) {}
  inline Encoding& operator=(const Encoding& from) {
    CopyFrom(from);
    return *this;
  }
  inline Encoding& operator=(Encoding&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  [[nodiscard]] inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const Encoding& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<Encoding>(&Encoding_globals_);
  }
  static constexpr int kIndexInFileMessages = 10;
  friend void swap(Encoding& a, Encoding& b) { a.Swap(&b); }
  inline void Swap(Encoding* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Encoding* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] Encoding* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<Encoding>(arena);
  }
  using Super_::CopyFrom;
  void CopyFrom(const Encoding& from);
  using Super_::MergeFrom;
  void MergeFrom(const Encoding& from) { Encoding::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(Encoding* PROTOBUF_NONNULL other);
 private:
  static ::absl::string_view FullMessageName() { return "mgard.pb.Encoding"; }

  explicit Encoding(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  Encoding(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Encoding& from);
  Encoding(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, Encoding&& from) noexcept
      : Encoding(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------
  using Preprocessor = Encoding_Preprocessor;
  static constexpr Preprocessor NOOP_PREPROCESSOR = Encoding_Preprocessor_NOOP_PREPROCESSOR;
  static constexpr Preprocessor SHUFFLE = Encoding_Preprocessor_SHUFFLE;
  [[nodiscard]] static inline bool Preprocessor_IsValid(int value) {
    return Encoding_Preprocessor_IsValid(value);
  }
  static constexpr Preprocessor Preprocessor_MIN = Encoding_Preprocessor_Preprocessor_MIN;
  static constexpr Preprocessor Preprocessor_MAX = Encoding_Preprocessor_Preprocessor_MAX;
  static constexpr int Preprocessor_ARRAYSIZE = Encoding_Preprocessor_Preprocessor_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL Preprocessor_descriptor() {
    return Encoding_Preprocessor_descriptor();
  }
  template <typename T>
  [[nodiscard]] static inline const ::std::string& Preprocessor_Name(T value) {
    return Encoding_Preprocessor_Name(value);
  }
  [[nodiscard]] static inline bool Preprocessor_Parse(
      ::absl::string_view name, Preprocessor* PROTOBUF_NONNULL value) {
    return Encoding_Preprocessor_Parse(name, value);
  }
  using Compressor = Encoding_Compressor;
  static constexpr Compressor NOOP_COMPRESSOR = Encoding_Compressor_NOOP_COMPRESSOR;
  static constexpr Compressor CPU_HUFFMAN_ZLIB = Encoding_Compressor_CPU_HUFFMAN_ZLIB;
  static constexpr Compressor CPU_HUFFMAN_ZSTD = Encoding_Compressor_CPU_HUFFMAN_ZSTD;
  static constexpr Compressor X_HUFFMAN = Encoding_Compressor_X_HUFFMAN;
  static constexpr Compressor X_HUFFMAN_LZ4 = Encoding_Compressor_X_HUFFMAN_LZ4;
  static constexpr Compressor X_HUFFMAN_ZSTD = Encoding_Compressor_X_HUFFMAN_ZSTD;
  [[nodiscard]] static inline bool Compressor_IsValid(int value) {
    return Encoding_Compressor_IsValid(value);
  }
  static constexpr Compressor Compressor_MIN = Encoding_Compressor_Compressor_MIN;
  static constexpr Compressor Compressor_MAX = Encoding_Compressor_Compressor_MAX;
  static constexpr int Compressor_ARRAYSIZE = Encoding_Compressor_Compressor_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL Compressor_descriptor() {
    return Encoding_Compressor_descriptor();
  }
  template <typename T>
  [[nodiscard]] static inline const ::std::string& Compressor_Name(T value) {
    return Encoding_Compressor_Name(value);
  }
  [[nodiscard]] static inline bool Compressor_Parse(
      ::absl::string_view name, Compressor* PROTOBUF_NONNULL value) {
    return Encoding_Compressor_Parse(name, value);
  }

  // accessors -------------------------------------------------------
  enum : int {
    kPreprocessorFieldNumber = 1,
    kCompressorFieldNumber = 2,
    kHuffmanDictionarySizeFieldNumber = 3,
    kHuffmanBlockSizeFieldNumber = 4,
  };
  // .mgard.pb.Encoding.Preprocessor preprocessor = 1;
  void clear_preprocessor() ;
  [[nodiscard]] ::mgard::pb::Encoding_Preprocessor preprocessor() const;
  void set_preprocessor(::mgard::pb::Encoding_Preprocessor value);

  private:
  ::mgard::pb::Encoding_Preprocessor _internal_preprocessor() const;
  void _internal_set_preprocessor(::mgard::pb::Encoding_Preprocessor value);

  public:
  // .mgard.pb.Encoding.Compressor compressor = 2;
  void clear_compressor() ;
  [[nodiscard]] ::mgard::pb::Encoding_Compressor compressor() const;
  void set_compressor(::mgard::pb::Encoding_Compressor value);

  private:
  ::mgard::pb::Encoding_Compressor _internal_compressor() const;
  void _internal_set_compressor(::mgard::pb::Encoding_Compressor value);

  public:
  // uint64 huffman_dictionary_size = 3;
  void clear_huffman_dictionary_size() ;
  [[nodiscard]] ::uint64_t huffman_dictionary_size() const;
  void set_huffman_dictionary_size(::uint64_t value);

  private:
  ::uint64_t _internal_huffman_dictionary_size() const;
  void _internal_set_huffman_dictionary_size(::uint64_t value);

  public:
  // uint64 huffman_block_size = 4;
  void clear_huffman_block_size() ;
  [[nodiscard]] ::uint64_t huffman_block_size() const;
  void set_huffman_block_size(::uint64_t value);

  private:
  ::uint64_t _internal_huffman_block_size() const;
  void _internal_set_huffman_block_size(::uint64_t value);

  public:
  // @@protoc_insertion_point(class_scope:mgard.pb.Encoding)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<2, 4,
                          0, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const Encoding& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    int preprocessor_;
    int compressor_;
    ::uint64_t huffman_dictionary_size_;
    ::uint64_t huffman_block_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_mgard_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED DomainDecomposition final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:mgard.pb.DomainDecomposition) */ {
  using Super_ = ::google::protobuf::Message;

 public:
  inline DomainDecomposition() : DomainDecomposition(nullptr) {}
  ~DomainDecomposition() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(DomainDecomposition* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(DomainDecomposition));
  }
#endif

  template <typename = void>
  explicit constexpr DomainDecomposition(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline DomainDecomposition(const DomainDecomposition& from) : DomainDecomposition(nullptr, from) {}
  inline DomainDecomposition(DomainDecomposition&& from) noexcept : DomainDecomposition(nullptr, ::std::move(from)) {}
  inline DomainDecomposition& operator=(const DomainDecomposition& from) {
    CopyFrom(from);
    return *this;
  }
  inline DomainDecomposition& operator=(DomainDecomposition&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  [[nodiscard]] inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const DomainDecomposition& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<DomainDecomposition>(&DomainDecomposition_globals_);
  }
  static constexpr int kIndexInFileMessages = 6;
  friend void swap(DomainDecomposition& a, DomainDecomposition& b) { a.Swap(&b); }
  inline void Swap(DomainDecomposition* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(DomainDecomposition* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] DomainDecomposition* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<DomainDecomposition>(arena);
  }
  using Super_::CopyFrom;
  void CopyFrom(const DomainDecomposition& from);
  using Super_::MergeFrom;
  void MergeFrom(const DomainDecomposition& from) { DomainDecomposition::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(DomainDecomposition* PROTOBUF_NONNULL other);
 private:
  static ::absl::string_view FullMessageName() { return "mgard.pb.DomainDecomposition"; }

  explicit DomainDecomposition(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  DomainDecomposition(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const DomainDecomposition& from);
  DomainDecomposition(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, DomainDecomposition&& from) noexcept
      : DomainDecomposition(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------
  using Method = DomainDecomposition_Method;
  static constexpr Method NOOP_METHOD = DomainDecomposition_Method_NOOP_METHOD;
  static constexpr Method MAX_DIMENSION = DomainDecomposition_Method_MAX_DIMENSION;
  static constexpr Method BLOCK = DomainDecomposition_Method_BLOCK;
  static constexpr Method VARIABLE = DomainDecomposition_Method_VARIABLE;
  [[nodiscard]] static inline bool Method_IsValid(int value) {
    return DomainDecomposition_Method_IsValid(value);
  }
  static constexpr Method Method_MIN = DomainDecomposition_Method_Method_MIN;
  static constexpr Method Method_MAX = DomainDecomposition_Method_Method_MAX;
  static constexpr int Method_ARRAYSIZE = DomainDecomposition_Method_Method_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL Method_descriptor() {
    return DomainDecomposition_Method_descriptor();
  }
  template <typename T>
  [[nodiscard]] static inline const ::std::string& Method_Name(T value) {
    return DomainDecomposition_Method_Name(value);
  }
  [[nodiscard]] static inline bool Method_Parse(
      ::absl::string_view name, Method* PROTOBUF_NONNULL value) {
    return DomainDecomposition_Method_Parse(name, value);
  }

  // accessors -------------------------------------------------------
  enum : int {
    kDecompositionDimensionFieldNumber = 2,
    kDecompositionSizeFieldNumber = 3,
    kMethodFieldNumber = 1,
  };
  // uint64 decomposition_dimension = 2;
  void clear_decomposition_dimension() ;
  [[nodiscard]] ::uint64_t decomposition_dimension() const;
  void set_decomposition_dimension(::uint64_t value);

  private:
  ::uint64_t _internal_decomposition_dimension() const;
  void _internal_set_decomposition_dimension(::uint64_t value);

  public:
  // uint64 decomposition_size = 3;
  void clear_decomposition_size() ;
  [[nodiscard]] ::uint64_t decomposition_size() const;
  void set_decomposition_size(::uint64_t value);

  private:
  ::uint64_t _internal_decomposition_size() const;
  void _internal_set_decomposition_size(::uint64_t value);

  public:
  // .mgard.pb.DomainDecomposition.Method method = 1;
  void clear_method() ;
  [[nodiscard]] ::mgard::pb::DomainDecomposition_Method method() const;
  void set_method(::mgard::pb::DomainDecomposition_Method value);

  private:
  ::mgard::pb::DomainDecomposition_Method _internal_method() const;
  void _internal_set_method(::mgard::pb::DomainDecomposition_Method value);

  public:
  // @@protoc_insertion_point(class_scope:mgard.pb.DomainDecomposition)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<2, 3,
                          0, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const DomainDecomposition& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::uint64_t decomposition_dimension_;
    ::uint64_t decomposition_size_;
    int method_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_mgard_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED Device final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:mgard.pb.Device) */ {
  using Super_ = ::google::protobuf::Message;

 public:
  inline Device() : Device(nullptr) {}
  ~Device() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(Device* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(Device));
  }
#endif

  template <typename = void>
  explicit constexpr Device(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline Device(const Device& from) : Device(nullptr, from) {}
  inline Device(Device&& from) noexcept : Device(nullptr, ::std::move(from)) {}
  inline Device& operator=(const Device& from) {
    CopyFrom(from);
    return *this;
  }
  inline Device& operator=(Device&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  [[nodiscard]] inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const Device& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<Device>(&Device_globals_);
  }
  static constexpr int kIndexInFileMessages = 11;
  friend void swap(Device& a, Device& b) { a.Swap(&b); }
  inline void Swap(Device* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Device* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] Device* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<Device>(arena);
  }
  using Super_::CopyFrom;
  void CopyFrom(const Device& from);
  using Super_::MergeFrom;
  void MergeFrom(const Device& from) { Device::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(Device* PROTOBUF_NONNULL other);
 private:
  static ::absl::string_view FullMessageName() { return "mgard.pb.Device"; }

  explicit Device(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  Device(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Device& from);
  Device(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, Device&& from) noexcept
      : Device(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------
  using Backend = Device_Backend;
  static constexpr Backend CPU = Device_Backend_CPU;
  static constexpr Backend X_SERIAL = Device_Backend_X_SERIAL;
  static constexpr Backend X_OPENMP = Device_Backend_X_OPENMP;
  static constexpr Backend X_CUDA = Device_Backend_X_CUDA;
  static constexpr Backend X_HIP = Device_Backend_X_HIP;
  static constexpr Backend X_SYCL = Device_Backend_X_SYCL;
  [[nodiscard]] static inline bool Backend_IsValid(int value) {
    return Device_Backend_IsValid(value);
  }
  static constexpr Backend Backend_MIN = Device_Backend_Backend_MIN;
  static constexpr Backend Backend_MAX = Device_Backend_Backend_MAX;
  static constexpr int Backend_ARRAYSIZE = Device_Backend_Backend_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL Backend_descriptor() {
    return Device_Backend_descriptor();
  }
  template <typename T>
  [[nodiscard]] static inline const ::std::string& Backend_Name(T value) {
    return Device_Backend_Name(value);
  }
  [[nodiscard]] static inline bool Backend_Parse(
      ::absl::string_view name, Backend* PROTOBUF_NONNULL value) {
    return Device_Backend_Parse(name, value);
  }

  // accessors -------------------------------------------------------
  enum : int {
    kBackendFieldNumber = 1,
  };
  // .mgard.pb.Device.Backend backend = 1;
  void clear_backend() ;
  [[nodiscard]] ::mgard::pb::Device_Backend backend() const;
  void set_backend(::mgard::pb::Device_Backend value);

  private:
  ::mgard::pb::Device_Backend _internal_backend() const;
  void _internal_set_backend(::mgard::pb::Device_Backend value);

  public:
  // @@protoc_insertion_point(class_scope:mgard.pb.Device)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<0, 1,
                          0, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const Device& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    int backend_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_mgard_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED Dataset final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:mgard.pb.Dataset) */ {
  using Super_ = ::google::protobuf::Message;

 public:
  inline Dataset() : Dataset(nullptr) {}
  ~Dataset() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(Dataset* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(Dataset));
  }
#endif

  template <typename = void>
  explicit constexpr Dataset(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline Dataset(const Dataset& from) : Dataset(nullptr, from) {}
  inline Dataset(Dataset&& from) noexcept : Dataset(nullptr, ::std::move(from)) {}
  inline Dataset& operator=(const Dataset& from) {
    CopyFrom(from);
    return *this;
  }
  inline Dataset& operator=(Dataset&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  [[nodiscard]] inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const Dataset& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<Dataset>(&Dataset_globals_);
  }
  static constexpr int kIndexInFileMessages = 4;
  friend void swap(Dataset& a, Dataset& b) { a.Swap(&b); }
  inline void Swap(Dataset* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Dataset* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] Dataset* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<Dataset>(arena);
  }
  using Super_::CopyFrom;
  void CopyFrom(const Dataset& from);
  using Super_::MergeFrom;
  void MergeFrom(const Dataset& from) { Dataset::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(Dataset* PROTOBUF_NONNULL other);
 private:
  static ::absl::string_view FullMessageName() { return "mgard.pb.Dataset"; }

  explicit Dataset(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  Dataset(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Dataset& from);
  Dataset(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, Dataset&& from) noexcept
      : Dataset(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------
  using Type = Dataset_Type;
  static constexpr Type FLOAT = Dataset_Type_FLOAT;
  static constexpr Type DOUBLE = Dataset_Type_DOUBLE;
  [[nodiscard]] static inline bool Type_IsValid(int value) {
    return Dataset_Type_IsValid(value);
  }
  static constexpr Type Type_MIN = Dataset_Type_Type_MIN;
  static constexpr Type Type_MAX = Dataset_Type_Type_MAX;
  static constexpr int Type_ARRAYSIZE = Dataset_Type_Type_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL Type_descriptor() {
    return Dataset_Type_descriptor();
  }
  template <typename T>
  [[nodiscard]] static inline const ::std::string& Type_Name(T value) {
    return Dataset_Type_Name(value);
  }
  [[nodiscard]] static inline bool Type_Parse(
      ::absl::string_view name, Type* PROTOBUF_NONNULL value) {
    return Dataset_Type_Parse(name, value);
  }

  // accessors -------------------------------------------------------
  enum : int {
    kDimensionFieldNumber = 2,
    kTypeFieldNumber = 1,
  };
  // uint64 dimension = 2;
  void clear_dimension() ;
  [[nodiscard]] ::uint64_t dimension() const;
  void set_dimension(::uint64_t value);

  private:
  ::uint64_t _internal_dimension() const;
  void _internal_set_dimension(::uint64_t value);

  public:
  // .mgard.pb.Dataset.Type type = 1;
  void clear_type() ;
  [[nodiscard]] ::mgard::pb::Dataset_Type type() const;
  void set_type(::mgard::pb::Dataset_Type value);

  private:
  ::mgard::pb::Dataset_Type _internal_type() const;
  void _internal_set_type(::mgard::pb::Dataset_Type value);

  public:
  // @@protoc_insertion_point(class_scope:mgard.pb.Dataset)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<1, 2,
                          0, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const Dataset& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::uint64_t dimension_;
    int type_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_mgard_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED CartesianGridTopology final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:mgard.pb.CartesianGridTopology) */ {
  using Super_ = ::google::protobuf::Message;

 public:
  inline CartesianGridTopology() : CartesianGridTopology(nullptr) {}
  ~CartesianGridTopology() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(CartesianGridTopology* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(CartesianGridTopology));
  }
#endif

  template <typename = void>
  explicit constexpr CartesianGridTopology(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline CartesianGridTopology(const CartesianGridTopology& from) : CartesianGridTopology(nullptr, from) {}
  inline CartesianGridTopology(CartesianGridTopology&& from) noexcept : CartesianGridTopology(nullptr, ::std::move(from)) {}
  inline CartesianGridTopology& operator=(const CartesianGridTopology& from) {
    CopyFrom(from);
    return *this;
  }
  inline CartesianGridTopology& operator=(CartesianGridTopology&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  [[nodiscard]] inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const CartesianGridTopology& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<CartesianGridTopology>(&CartesianGridTopology_globals_);
  }
  static constexpr int kIndexInFileMessages = 1;
  friend void swap(CartesianGridTopology& a, CartesianGridTopology& b) { a.Swap(&b); }
  inline void Swap(CartesianGridTopology* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CartesianGridTopology* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] CartesianGridTopology* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<CartesianGridTopology>(arena);
  }
  using Super_::CopyFrom;
  void CopyFrom(const CartesianGridTopology& from);
  using Super_::MergeFrom;
  void MergeFrom(const CartesianGridTopology& from) { CartesianGridTopology::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(CartesianGridTopology* PROTOBUF_NONNULL other);
 private:
  static ::absl::string_view FullMessageName() { return "mgard.pb.CartesianGridTopology"; }

  explicit CartesianGridTopology(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  CartesianGridTopology(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const CartesianGridTopology& from);
  CartesianGridTopology(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, CartesianGridTopology&& from) noexcept
      : CartesianGridTopology(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kShapeFieldNumber = 2,
    kDimensionFieldNumber = 1,
  };
  // repeated uint64 shape = 2;
  [[nodiscard]] int shape_size() const;
  private:
  int _internal_shape_size() const;

  public:
  void clear_shape() ;
  [[nodiscard]] ::uint64_t shape(int index) const;
  void set_shape(int index, ::uint64_t value);
  void add_shape(::uint64_t value);
  [[nodiscard]] const ::google::protobuf::RepeatedField<::uint64_t>& shape()
      const;
  ::google::protobuf::RepeatedField<::uint64_t>* PROTOBUF_NONNULL mutable_shape();

  private:
  const ::google::protobuf::RepeatedField<::uint64_t>& _internal_shape() const;
  ::google::protobuf::RepeatedField<::uint64_t>* PROTOBUF_NONNULL _internal_mutable_shape();

  public:
  // uint64 dimension = 1;
  void clear_dimension() ;
  [[nodiscard]] ::uint64_t dimension() const;
  void set_dimension(::uint64_t value);

  private:
  ::uint64_t _internal_dimension() const;
  void _internal_set_dimension(::uint64_t value);

  public:
  // @@protoc_insertion_point(class_scope:mgard.pb.CartesianGridTopology)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<1, 2,
                          0, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const CartesianGridTopology& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedField<::uint64_t> shape_;
    ::uint64_t dimension_;
    ::google::protobuf::internal::CachedSize _shape_cached_byte_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_mgard_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED BitplaneEncoding final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:mgard.pb.BitplaneEncoding) */ {
  using Super_ = ::google::protobuf::Message;

 public:
  inline BitplaneEncoding() : BitplaneEncoding(nullptr) {}
  ~BitplaneEncoding() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(BitplaneEncoding* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(BitplaneEncoding));
  }
#endif

  template <typename = void>
  explicit constexpr BitplaneEncoding(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline BitplaneEncoding(const BitplaneEncoding& from) : BitplaneEncoding(nullptr, from) {}
  inline BitplaneEncoding(BitplaneEncoding&& from) noexcept : BitplaneEncoding(nullptr, ::std::move(from)) {}
  inline BitplaneEncoding& operator=(const BitplaneEncoding& from) {
    CopyFrom(from);
    return *this;
  }
  inline BitplaneEncoding& operator=(BitplaneEncoding&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  [[nodiscard]] inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const BitplaneEncoding& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<BitplaneEncoding>(&BitplaneEncoding_globals_);
  }
  static constexpr int kIndexInFileMessages = 9;
  friend void swap(BitplaneEncoding& a, BitplaneEncoding& b) { a.Swap(&b); }
  inline void Swap(BitplaneEncoding* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(BitplaneEncoding* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] BitplaneEncoding* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<BitplaneEncoding>(arena);
  }
  using Super_::CopyFrom;
  void CopyFrom(const BitplaneEncoding& from);
  using Super_::MergeFrom;
  void MergeFrom(const BitplaneEncoding& from) { BitplaneEncoding::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(BitplaneEncoding* PROTOBUF_NONNULL other);
 private:
  static ::absl::string_view FullMessageName() { return "mgard.pb.BitplaneEncoding"; }

  explicit BitplaneEncoding(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  BitplaneEncoding(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const BitplaneEncoding& from);
  BitplaneEncoding(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, BitplaneEncoding&& from) noexcept
      : BitplaneEncoding(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------
  using Method = BitplaneEncoding_Method;
  static constexpr Method NOOP_BITPLANE_ENCODING = BitplaneEncoding_Method_NOOP_BITPLANE_ENCODING;
  static constexpr Method GROUPED_BITPLANE_ENCODING = BitplaneEncoding_Method_GROUPED_BITPLANE_ENCODING;
  [[nodiscard]] static inline bool Method_IsValid(int value) {
    return BitplaneEncoding_Method_IsValid(value);
  }
  static constexpr Method Method_MIN = BitplaneEncoding_Method_Method_MIN;
  static constexpr Method Method_MAX = BitplaneEncoding_Method_Method_MAX;
  static constexpr int Method_ARRAYSIZE = BitplaneEncoding_Method_Method_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL Method_descriptor() {
    return BitplaneEncoding_Method_descriptor();
  }
  template <typename T>
  [[nodiscard]] static inline const ::std::string& Method_Name(T value) {
    return BitplaneEncoding_Method_Name(value);
  }
  [[nodiscard]] static inline bool Method_Parse(
      ::absl::string_view name, Method* PROTOBUF_NONNULL value) {
    return BitplaneEncoding_Method_Parse(name, value);
  }
  using Type = BitplaneEncoding_Type;
  static constexpr Type INT8_T = BitplaneEncoding_Type_INT8_T;
  static constexpr Type INT16_T = BitplaneEncoding_Type_INT16_T;
  static constexpr Type INT32_T = BitplaneEncoding_Type_INT32_T;
  static constexpr Type INT64_T = BitplaneEncoding_Type_INT64_T;
  [[nodiscard]] static inline bool Type_IsValid(int value) {
    return BitplaneEncoding_Type_IsValid(value);
  }
  static constexpr Type Type_MIN = BitplaneEncoding_Type_Type_MIN;
  static constexpr Type Type_MAX = BitplaneEncoding_Type_Type_MAX;
  static constexpr int Type_ARRAYSIZE = BitplaneEncoding_Type_Type_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL Type_descriptor() {
    return BitplaneEncoding_Type_descriptor();
  }
  template <typename T>
  [[nodiscard]] static inline const ::std::string& Type_Name(T value) {
    return BitplaneEncoding_Type_Name(value);
  }
  [[nodiscard]] static inline bool Type_Parse(
      ::absl::string_view name, Type* PROTOBUF_NONNULL value) {
    return BitplaneEncoding_Type_Parse(name, value);
  }

  // accessors -------------------------------------------------------
  enum : int {
    kMethodFieldNumber = 1,
    kTypeFieldNumber = 2,
    kNumberBitplanesFieldNumber = 3,
    kBigEndianFieldNumber = 4,
  };
  // .mgard.pb.BitplaneEncoding.Method method = 1;
  void clear_method() ;
  [[nodiscard]] ::mgard::pb::BitplaneEncoding_Method method() const;
  void set_method(::mgard::pb::BitplaneEncoding_Method value);

  private:
  ::mgard::pb::BitplaneEncoding_Method _internal_method() const;
  void _internal_set_method(::mgard::pb::BitplaneEncoding_Method value);

  public:
  // .mgard.pb.BitplaneEncoding.Type type = 2;
  void clear_type() ;
  [[nodiscard]] ::mgard::pb::BitplaneEncoding_Type type() const;
  void set_type(::mgard::pb::BitplaneEncoding_Type value);

  private:
  ::mgard::pb::BitplaneEncoding_Type _internal_type() const;
  void _internal_set_type(::mgard::pb::BitplaneEncoding_Type value);

  public:
  // uint64 number_bitplanes = 3;
  void clear_number_bitplanes() ;
  [[nodiscard]] ::uint64_t number_bitplanes() const;
  void set_number_bitplanes(::uint64_t value);

  private:
  ::uint64_t _internal_number_bitplanes() const;
  void _internal_set_number_bitplanes(::uint64_t value);

  public:
  // bool big_endian = 4;
  void clear_big_endian() ;
  [[nodiscard]] bool big_endian() const;
  void set_big_endian(bool value);

  private:
  bool _internal_big_endian() const;
  void _internal_set_big_endian(bool value);

  public:
  // @@protoc_insertion_point(class_scope:mgard.pb.BitplaneEncoding)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<2, 4,
                          0, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const BitplaneEncoding& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    int method_;
    int type_;
    ::uint64_t number_bitplanes_;
    bool big_endian_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_mgard_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED Domain final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:mgard.pb.Domain) */ {
  using Super_ = ::google::protobuf::Message;

 public:
  inline Domain() : Domain(nullptr) {}
  ~Domain() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(Domain* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(Domain));
  }
#endif

  template <typename = void>
  explicit constexpr Domain(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline Domain(const Domain& from) : Domain(nullptr, from) {}
  inline Domain(Domain&& from) noexcept : Domain(nullptr, ::std::move(from)) {}
  inline Domain& operator=(const Domain& from) {
    CopyFrom(from);
    return *this;
  }
  inline Domain& operator=(Domain&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  [[nodiscard]] inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const Domain& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<Domain>(&Domain_globals_);
  }
  enum TopologyDefinitionCase {
    kCartesianGridTopology = 2,
    TOPOLOGY_DEFINITION_NOT_SET = 0,
  };
  enum GeometryDefinitionCase {
    kExplicitCubeGeometry = 4,
    kExplicitCubeFilename = 5,
    GEOMETRY_DEFINITION_NOT_SET = 0,
  };
  static constexpr int kIndexInFileMessages = 3;
  friend void swap(Domain& a, Domain& b) { a.Swap(&b); }
  inline void Swap(Domain* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Domain* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] Domain* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<Domain>(arena);
  }
  using Super_::CopyFrom;
  void CopyFrom(const Domain& from);
  using Super_::MergeFrom;
  void MergeFrom(const Domain& from) { Domain::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(Domain* PROTOBUF_NONNULL other);
 private:
  static ::absl::string_view FullMessageName() { return "mgard.pb.Domain"; }

  explicit Domain(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  Domain(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Domain& from);
  Domain(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, Domain&& from) noexcept
      : Domain(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------
  using Topology = Domain_Topology;
  static constexpr Topology CARTESIAN_GRID = Domain_Topology_CARTESIAN_GRID;
  [[nodiscard]] static inline bool Topology_IsValid(int value) {
    return Domain_Topology_IsValid(value);
  }
  static constexpr Topology Topology_MIN = Domain_Topology_Topology_MIN;
  static constexpr Topology Topology_MAX = Domain_Topology_Topology_MAX;
  static constexpr int Topology_ARRAYSIZE = Domain_Topology_Topology_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL Topology_descriptor() {
    return Domain_Topology_descriptor();
  }
  template <typename T>
  [[nodiscard]] static inline const ::std::string& Topology_Name(T value) {
    return Domain_Topology_Name(value);
  }
  [[nodiscard]] static inline bool Topology_Parse(
      ::absl::string_view name, Topology* PROTOBUF_NONNULL value) {
    return Domain_Topology_Parse(name, value);
  }
  using Geometry = Domain_Geometry;
  static constexpr Geometry UNIT_CUBE = Domain_Geometry_UNIT_CUBE;
  static constexpr Geometry EXPLICIT_CUBE = Domain_Geometry_EXPLICIT_CUBE;
  [[nodiscard]] static inline bool Geometry_IsValid(int value) {
    return Domain_Geometry_IsValid(value);
  }
  static constexpr Geometry Geometry_MIN = Domain_Geometry_Geometry_MIN;
  static constexpr Geometry Geometry_MAX = Domain_Geometry_Geometry_MAX;
  static constexpr int Geometry_ARRAYSIZE = Domain_Geometry_Geometry_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL Geometry_descriptor() {
    return Domain_Geometry_descriptor();
  }
  template <typename T>
  [[nodiscard]] static inline const ::std::string& Geometry_Name(T value) {
    return Domain_Geometry_Name(value);
  }
  [[nodiscard]] static inline bool Geometry_Parse(
      ::absl::string_view name, Geometry* PROTOBUF_NONNULL value) {
    return Domain_Geometry_Parse(name, value);
  }

  // accessors -------------------------------------------------------
  enum : int {
    kTopologyFieldNumber = 1,
    kGeometryFieldNumber = 3,
    kCartesianGridTopologyFieldNumber = 2,
    kExplicitCubeGeometryFieldNumber = 4,
    kExplicitCubeFilenameFieldNumber = 5,
  };
  // .mgard.pb.Domain.Topology topology = 1;
  void clear_topology() ;
  [[nodiscard]] ::mgard::pb::Domain_Topology topology() const;
  void set_topology(::mgard::pb::Domain_Topology value);

  private:
  ::mgard::pb::Domain_Topology _internal_topology() const;
  void _internal_set_topology(::mgard::pb::Domain_Topology value);

  public:
  // .mgard.pb.Domain.Geometry geometry = 3;
  void clear_geometry() ;
  [[nodiscard]] ::mgard::pb::Domain_Geometry geometry() const;
  void set_geometry(::mgard::pb::Domain_Geometry value);

  private:
  ::mgard::pb::Domain_Geometry _internal_geometry() const;
  void _internal_set_geometry(::mgard::pb::Domain_Geometry value);

  public:
  // .mgard.pb.CartesianGridTopology cartesian_grid_topology = 2;
  [[nodiscard]] bool has_cartesian_grid_topology() const;
  private:
  bool _internal_has_cartesian_grid_topology() const;

  public:
  void clear_cartesian_grid_topology() ;
  [[nodiscard]] const ::mgard::pb::CartesianGridTopology& cartesian_grid_topology() const;
  [[nodiscard]] ::mgard::pb::CartesianGridTopology* PROTOBUF_NULLABLE release_cartesian_grid_topology();
  ::mgard::pb::CartesianGridTopology* PROTOBUF_NONNULL mutable_cartesian_grid_topology();
  void set_allocated_cartesian_grid_topology(::mgard::pb::CartesianGridTopology* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_cartesian_grid_topology(::mgard::pb::CartesianGridTopology* PROTOBUF_NULLABLE value);
  ::mgard::pb::CartesianGridTopology* PROTOBUF_NULLABLE unsafe_arena_release_cartesian_grid_topology();

  private:
  const ::mgard::pb::CartesianGridTopology& _internal_cartesian_grid_topology() const;
  ::mgard::pb::CartesianGridTopology* PROTOBUF_NONNULL _internal_mutable_cartesian_grid_topology();

  public:
  // .mgard.pb.ExplicitCubeGeometry explicit_cube_geometry = 4;
  [[nodiscard]] bool has_explicit_cube_geometry() const;
  private:
  bool _internal_has_explicit_cube_geometry() const;

  public:
  void clear_explicit_cube_geometry() ;
  [[nodiscard]] const ::mgard::pb::ExplicitCubeGeometry& explicit_cube_geometry() const;
  [[nodiscard]] ::mgard::pb::ExplicitCubeGeometry* PROTOBUF_NULLABLE release_explicit_cube_geometry();
  ::mgard::pb::ExplicitCubeGeometry* PROTOBUF_NONNULL mutable_explicit_cube_geometry();
  void set_allocated_explicit_cube_geometry(::mgard::pb::ExplicitCubeGeometry* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_explicit_cube_geometry(::mgard::pb::ExplicitCubeGeometry* PROTOBUF_NULLABLE value);
  ::mgard::pb::ExplicitCubeGeometry* PROTOBUF_NULLABLE unsafe_arena_release_explicit_cube_geometry();

  private:
  const ::mgard::pb::ExplicitCubeGeometry& _internal_explicit_cube_geometry() const;
  ::mgard::pb::ExplicitCubeGeometry* PROTOBUF_NONNULL _internal_mutable_explicit_cube_geometry();

  public:
  // string explicit_cube_filename = 5;
  [[nodiscard]] bool has_explicit_cube_filename() const;
  void clear_explicit_cube_filename() ;
  [[nodiscard]] const ::std::string& explicit_cube_filename() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_explicit_cube_filename(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_explicit_cube_filename();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_explicit_cube_filename();
  void set_allocated_explicit_cube_filename(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_explicit_cube_filename() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_explicit_cube_filename(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_explicit_cube_filename();

  public:
  void clear_topology_definition();
  TopologyDefinitionCase topology_definition_case() const;
  void clear_geometry_definition();
  GeometryDefinitionCase geometry_definition_case() const;
  // @@protoc_insertion_point(class_scope:mgard.pb.Domain)
 private:
  class _Internal;
  void set_has_cartesian_grid_topology();
  void set_has_explicit_cube_geometry();
  void set_has_explicit_cube_filename();
  [[nodiscard]] inline bool has_topology_definition() const;
  inline void clear_has_topology_definition();
  [[nodiscard]] inline bool has_geometry_definition() const;
  inline void clear_has_geometry_definition();
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<2, 5,
                          2, 46,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const Domain& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    int topology_;
    int geometry_;
    union TopologyDefinitionUnion {
      constexpr TopologyDefinitionUnion() : _constinit_{} {}
      ::google::protobuf::internal::ConstantInitialized _constinit_;
      ::mgard::pb::CartesianGridTopology* PROTOBUF_NULLABLE cartesian_grid_topology_;
    } topology_definition_;
    union GeometryDefinitionUnion {
      constexpr GeometryDefinitionUnion() : _constinit_{} {}
      ::google::protobuf::internal::ConstantInitialized _constinit_;
      ::mgard::pb::ExplicitCubeGeometry* PROTOBUF_NULLABLE explicit_cube_geometry_;
      ::google::protobuf::internal::ArenaStringPtr explicit_cube_filename_;
    } geometry_definition_;
    ::uint32_t _oneof_case_[2];
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_mgard_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED Header final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:mgard.pb.Header) */ {
  using Super_ = ::google::protobuf::Message;

 public:
  inline Header() : Header(nullptr) {}
  ~Header() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(Header* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(Header));
  }
#endif

  template <typename = void>
  explicit constexpr Header(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline Header(const Header& from) : Header(nullptr, from) {}
  inline Header(Header&& from) noexcept : Header(nullptr, ::std::move(from)) {}
  inline Header& operator=(const Header& from) {
    CopyFrom(from);
    return *this;
  }
  inline Header& operator=(Header&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  [[nodiscard]] inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const Header& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<Header>(&Header_globals_);
  }
  static constexpr int kIndexInFileMessages = 12;
  friend void swap(Header& a, Header& b) { a.Swap(&b); }
  inline void Swap(Header* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Header* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] Header* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<Header>(arena);
  }
  using Super_::CopyFrom;
  void CopyFrom(const Header& from);
  using Super_::MergeFrom;
  void MergeFrom(const Header& from) { Header::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(Header* PROTOBUF_NONNULL other);
 private:
  static ::absl::string_view FullMessageName() { return "mgard.pb.Header"; }

  explicit Header(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  Header(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Header& from);
  Header(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, Header&& from) noexcept
      : Header(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kMgardVersionFieldNumber = 2,
    kFileFormatVersionFieldNumber = 3,
    kDomainFieldNumber = 4,
    kDatasetFieldNumber = 5,
    kErrorControlFieldNumber = 6,
    kDomainDecompositionFieldNumber = 7,
    kFunctionDecompositionFieldNumber = 8,
    kQuantizationFieldNumber = 9,
    kBitplaneEncodingFieldNumber = 10,
    kEncodingFieldNumber = 11,
    kDeviceFieldNumber = 12,
  };
  // .mgard.pb.VersionNumber mgard_version = 2;
  [[nodiscard]] bool has_mgard_version() const;
  void clear_mgard_version() ;
  [[nodiscard]] const ::mgard::pb::VersionNumber& mgard_version() const;
  [[nodiscard]] ::mgard::pb::VersionNumber* PROTOBUF_NULLABLE release_mgard_version();
  ::mgard::pb::VersionNumber* PROTOBUF_NONNULL mutable_mgard_version();
  void set_allocated_mgard_version(::mgard::pb::VersionNumber* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_mgard_version(::mgard::pb::VersionNumber* PROTOBUF_NULLABLE value);
  ::mgard::pb::VersionNumber* PROTOBUF_NULLABLE unsafe_arena_release_mgard_version();

  private:
  const ::mgard::pb::VersionNumber& _internal_mgard_version() const;
  ::mgard::pb::VersionNumber* PROTOBUF_NONNULL _internal_mutable_mgard_version();

  public:
  // .mgard.pb.VersionNumber file_format_version = 3;
  [[nodiscard]] bool has_file_format_version() const;
  void clear_file_format_version() ;
  [[nodiscard]] const ::mgard::pb::VersionNumber& file_format_version() const;
  [[nodiscard]] ::mgard::pb::VersionNumber* PROTOBUF_NULLABLE release_file_format_version();
  ::mgard::pb::VersionNumber* PROTOBUF_NONNULL mutable_file_format_version();
  void set_allocated_file_format_version(::mgard::pb::VersionNumber* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_file_format_version(::mgard::pb::VersionNumber* PROTOBUF_NULLABLE value);
  ::mgard::pb::VersionNumber* PROTOBUF_NULLABLE unsafe_arena_release_file_format_version();

  private:
  const ::mgard::pb::VersionNumber& _internal_file_format_version() const;
  ::mgard::pb::VersionNumber* PROTOBUF_NONNULL _internal_mutable_file_format_version();

  public:
  // .mgard.pb.Domain domain = 4;
  [[nodiscard]] bool has_domain() const;
  void clear_domain() ;
  [[nodiscard]] const ::mgard::pb::Domain& domain() const;
  [[nodiscard]] ::mgard::pb::Domain* PROTOBUF_NULLABLE release_domain();
  ::mgard::pb::Domain* PROTOBUF_NONNULL mutable_domain();
  void set_allocated_domain(::mgard::pb::Domain* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_domain(::mgard::pb::Domain* PROTOBUF_NULLABLE value);
  ::mgard::pb::Domain* PROTOBUF_NULLABLE unsafe_arena_release_domain();

  private:
  const ::mgard::pb::Domain& _internal_domain() const;
  ::mgard::pb::Domain* PROTOBUF_NONNULL _internal_mutable_domain();

  public:
  // .mgard.pb.Dataset dataset = 5;
  [[nodiscard]] bool has_dataset() const;
  void clear_dataset() ;
  [[nodiscard]] const ::mgard::pb::Dataset& dataset() const;
  [[nodiscard]] ::mgard::pb::Dataset* PROTOBUF_NULLABLE release_dataset();
  ::mgard::pb::Dataset* PROTOBUF_NONNULL mutable_dataset();
  void set_allocated_dataset(::mgard::pb::Dataset* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_dataset(::mgard::pb::Dataset* PROTOBUF_NULLABLE value);
  ::mgard::pb::Dataset* PROTOBUF_NULLABLE unsafe_arena_release_dataset();

  private:
  const ::mgard::pb::Dataset& _internal_dataset() const;
  ::mgard::pb::Dataset* PROTOBUF_NONNULL _internal_mutable_dataset();

  public:
  // .mgard.pb.ErrorControl error_control = 6;
  [[nodiscard]] bool has_error_control() const;
  void clear_error_control() ;
  [[nodiscard]] const ::mgard::pb::ErrorControl& error_control() const;
  [[nodiscard]] ::mgard::pb::ErrorControl* PROTOBUF_NULLABLE release_error_control();
  ::mgard::pb::ErrorControl* PROTOBUF_NONNULL mutable_error_control();
  void set_allocated_error_control(::mgard::pb::ErrorControl* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_error_control(::mgard::pb::ErrorControl* PROTOBUF_NULLABLE value);
  ::mgard::pb::ErrorControl* PROTOBUF_NULLABLE unsafe_arena_release_error_control();

  private:
  const ::mgard::pb::ErrorControl& _internal_error_control() const;
  ::mgard::pb::ErrorControl* PROTOBUF_NONNULL _internal_mutable_error_control();

  public:
  // .mgard.pb.DomainDecomposition domain_decomposition = 7;
  [[nodiscard]] bool has_domain_decomposition() const;
  void clear_domain_decomposition() ;
  [[nodiscard]] const ::mgard::pb::DomainDecomposition& domain_decomposition() const;
  [[nodiscard]] ::mgard::pb::DomainDecomposition* PROTOBUF_NULLABLE release_domain_decomposition();
  ::mgard::pb::DomainDecomposition* PROTOBUF_NONNULL mutable_domain_decomposition();
  void set_allocated_domain_decomposition(::mgard::pb::DomainDecomposition* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_domain_decomposition(::mgard::pb::DomainDecomposition* PROTOBUF_NULLABLE value);
  ::mgard::pb::DomainDecomposition* PROTOBUF_NULLABLE unsafe_arena_release_domain_decomposition();

  private:
  const ::mgard::pb::DomainDecomposition& _internal_domain_decomposition() const;
  ::mgard::pb::DomainDecomposition* PROTOBUF_NONNULL _internal_mutable_domain_decomposition();

  public:
  // .mgard.pb.FunctionDecomposition function_decomposition = 8;
  [[nodiscard]] bool has_function_decomposition() const;
  void clear_function_decomposition() ;
  [[nodiscard]] const ::mgard::pb::FunctionDecomposition& function_decomposition() const;
  [[nodiscard]] ::mgard::pb::FunctionDecomposition* PROTOBUF_NULLABLE release_function_decomposition();
  ::mgard::pb::FunctionDecomposition* PROTOBUF_NONNULL mutable_function_decomposition();
  void set_allocated_function_decomposition(::mgard::pb::FunctionDecomposition* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_function_decomposition(::mgard::pb::FunctionDecomposition* PROTOBUF_NULLABLE value);
  ::mgard::pb::FunctionDecomposition* PROTOBUF_NULLABLE unsafe_arena_release_function_decomposition();

  private:
  const ::mgard::pb::FunctionDecomposition& _internal_function_decomposition() const;
  ::mgard::pb::FunctionDecomposition* PROTOBUF_NONNULL _internal_mutable_function_decomposition();

  public:
  // .mgard.pb.Quantization quantization = 9;
  [[nodiscard]] bool has_quantization() const;
  void clear_quantization() ;
  [[nodiscard]] const ::mgard::pb::Quantization& quantization() const;
  [[nodiscard]] ::mgard::pb::Quantization* PROTOBUF_NULLABLE release_quantization();
  ::mgard::pb::Quantization* PROTOBUF_NONNULL mutable_quantization();
  void set_allocated_quantization(::mgard::pb::Quantization* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_quantization(::mgard::pb::Quantization* PROTOBUF_NULLABLE value);
  ::mgard::pb::Quantization* PROTOBUF_NULLABLE unsafe_arena_release_quantization();

  private:
  const ::mgard::pb::Quantization& _internal_quantization() const;
  ::mgard::pb::Quantization* PROTOBUF_NONNULL _internal_mutable_quantization();

  public:
  // .mgard.pb.BitplaneEncoding bitplane_encoding = 10;
  [[nodiscard]] bool has_bitplane_encoding() const;
  void clear_bitplane_encoding() ;
  [[nodiscard]] const ::mgard::pb::BitplaneEncoding& bitplane_encoding() const;
  [[nodiscard]] ::mgard::pb::BitplaneEncoding* PROTOBUF_NULLABLE release_bitplane_encoding();
  ::mgard::pb::BitplaneEncoding* PROTOBUF_NONNULL mutable_bitplane_encoding();
  void set_allocated_bitplane_encoding(::mgard::pb::BitplaneEncoding* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_bitplane_encoding(::mgard::pb::BitplaneEncoding* PROTOBUF_NULLABLE value);
  ::mgard::pb::BitplaneEncoding* PROTOBUF_NULLABLE unsafe_arena_release_bitplane_encoding();

  private:
  const ::mgard::pb::BitplaneEncoding& _internal_bitplane_encoding() const;
  ::mgard::pb::BitplaneEncoding* PROTOBUF_NONNULL _internal_mutable_bitplane_encoding();

  public:
  // .mgard.pb.Encoding encoding = 11;
  [[nodiscard]] bool has_encoding() const;
  void clear_encoding() ;
  [[nodiscard]] const ::mgard::pb::Encoding& encoding() const;
  [[nodiscard]] ::mgard::pb::Encoding* PROTOBUF_NULLABLE release_encoding();
  ::mgard::pb::Encoding* PROTOBUF_NONNULL mutable_encoding();
  void set_allocated_encoding(::mgard::pb::Encoding* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_encoding(::mgard::pb::Encoding* PROTOBUF_NULLABLE value);
  ::mgard::pb::Encoding* PROTOBUF_NULLABLE unsafe_arena_release_encoding();

  private:
  const ::mgard::pb::Encoding& _internal_encoding() const;
  ::mgard::pb::Encoding* PROTOBUF_NONNULL _internal_mutable_encoding();

  public:
  // .mgard.pb.Device device = 12;
  [[nodiscard]] bool has_device() const;
  void clear_device() ;
  [[nodiscard]] const ::mgard::pb::Device& device() const;
  [[nodiscard]] ::mgard::pb::Device* PROTOBUF_NULLABLE release_device();
  ::mgard::pb::Device* PROTOBUF_NONNULL mutable_device();
  void set_allocated_device(::mgard::pb::Device* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_device(::mgard::pb::Device* PROTOBUF_NULLABLE value);
  ::mgard::pb::Device* PROTOBUF_NULLABLE unsafe_arena_release_device();

  private:
  const ::mgard::pb::Device& _internal_device() const;
  ::mgard::pb::Device* PROTOBUF_NONNULL _internal_mutable_device();

  public:
  // @@protoc_insertion_point(class_scope:mgard.pb.Header)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<4, 11,
                          11, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const Header& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::mgard::pb::VersionNumber* PROTOBUF_NULLABLE mgard_version_;
    ::mgard::pb::VersionNumber* PROTOBUF_NULLABLE file_format_version_;
    ::mgard::pb::Domain* PROTOBUF_NULLABLE domain_;
    ::mgard::pb::Dataset* PROTOBUF_NULLABLE dataset_;
    ::mgard::pb::ErrorControl* PROTOBUF_NULLABLE error_control_;
    ::mgard::pb::DomainDecomposition* PROTOBUF_NULLABLE domain_decomposition_;
    ::mgard::pb::FunctionDecomposition* PROTOBUF_NULLABLE function_decomposition_;
    ::mgard::pb::Quantization* PROTOBUF_NULLABLE quantization_;
    ::mgard::pb::BitplaneEncoding* PROTOBUF_NULLABLE bitplane_encoding_;
    ::mgard::pb::Encoding* PROTOBUF_NULLABLE encoding_;
    ::mgard::pb::Device* PROTOBUF_NULLABLE device_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_mgard_2eproto;
};

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




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


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

// VersionNumber

// uint64 major_ = 1;
inline void VersionNumber::clear_major_() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.major__ = ::uint64_t{0u};
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline ::uint64_t VersionNumber::major_() const {
  // @@protoc_insertion_point(field_get:mgard.pb.VersionNumber.major_)
  return _internal_major_();
}
inline void VersionNumber::set_major_(::uint64_t value) {
  _internal_set_major_(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_set:mgard.pb.VersionNumber.major_)
}
inline ::uint64_t VersionNumber::_internal_major_() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.major__;
}
inline void VersionNumber::_internal_set_major_(::uint64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.major__ = value;
}

// uint64 minor_ = 2;
inline void VersionNumber::clear_minor_() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.minor__ = ::uint64_t{0u};
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline ::uint64_t VersionNumber::minor_() const {
  // @@protoc_insertion_point(field_get:mgard.pb.VersionNumber.minor_)
  return _internal_minor_();
}
inline void VersionNumber::set_minor_(::uint64_t value) {
  _internal_set_minor_(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_set:mgard.pb.VersionNumber.minor_)
}
inline ::uint64_t VersionNumber::_internal_minor_() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.minor__;
}
inline void VersionNumber::_internal_set_minor_(::uint64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.minor__ = value;
}

// uint64 patch_ = 3;
inline void VersionNumber::clear_patch_() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.patch__ = ::uint64_t{0u};
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline ::uint64_t VersionNumber::patch_() const {
  // @@protoc_insertion_point(field_get:mgard.pb.VersionNumber.patch_)
  return _internal_patch_();
}
inline void VersionNumber::set_patch_(::uint64_t value) {
  _internal_set_patch_(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_set:mgard.pb.VersionNumber.patch_)
}
inline ::uint64_t VersionNumber::_internal_patch_() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.patch__;
}
inline void VersionNumber::_internal_set_patch_(::uint64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.patch__ = value;
}

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

// CartesianGridTopology

// uint64 dimension = 1;
inline void CartesianGridTopology::clear_dimension() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.dimension_ = ::uint64_t{0u};
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline ::uint64_t CartesianGridTopology::dimension() const {
  // @@protoc_insertion_point(field_get:mgard.pb.CartesianGridTopology.dimension)
  return _internal_dimension();
}
inline void CartesianGridTopology::set_dimension(::uint64_t value) {
  _internal_set_dimension(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_set:mgard.pb.CartesianGridTopology.dimension)
}
inline ::uint64_t CartesianGridTopology::_internal_dimension() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.dimension_;
}
inline void CartesianGridTopology::_internal_set_dimension(::uint64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.dimension_ = value;
}

// repeated uint64 shape = 2;
inline int CartesianGridTopology::_internal_shape_size() const {
  return _internal_shape().size();
}
inline int CartesianGridTopology::shape_size() const {
  return _internal_shape_size();
}
inline void CartesianGridTopology::clear_shape() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.shape_.Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline ::uint64_t CartesianGridTopology::shape(int index) const {
  // @@protoc_insertion_point(field_get:mgard.pb.CartesianGridTopology.shape)
  return _internal_shape().Get(index);
}
inline void CartesianGridTopology::set_shape(int index, ::uint64_t value) {
  _internal_mutable_shape()->Set(index, value);
  // @@protoc_insertion_point(field_set:mgard.pb.CartesianGridTopology.shape)
}
inline void CartesianGridTopology::add_shape(::uint64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _internal_mutable_shape()
      ->InternalAddWithArena<const ::google::protobuf::MessageLite*>(
          internal_visibility(), this, value);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_add:mgard.pb.CartesianGridTopology.shape)
}
inline const ::google::protobuf::RepeatedField<::uint64_t>& CartesianGridTopology::shape() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:mgard.pb.CartesianGridTopology.shape)
  return _internal_shape();
}
inline ::google::protobuf::RepeatedField<::uint64_t>* PROTOBUF_NONNULL CartesianGridTopology::mutable_shape()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_mutable_list:mgard.pb.CartesianGridTopology.shape)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_shape();
}
inline const ::google::protobuf::RepeatedField<::uint64_t>&
CartesianGridTopology::_internal_shape() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.shape_;
}
inline ::google::protobuf::RepeatedField<::uint64_t>* PROTOBUF_NONNULL
CartesianGridTopology::_internal_mutable_shape() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.shape_;
}

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

// ExplicitCubeGeometry

// repeated double coordinates = 2;
inline int ExplicitCubeGeometry::_internal_coordinates_size() const {
  return _internal_coordinates().size();
}
inline int ExplicitCubeGeometry::coordinates_size() const {
  return _internal_coordinates_size();
}
inline void ExplicitCubeGeometry::clear_coordinates() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.coordinates_.Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline double ExplicitCubeGeometry::coordinates(int index) const {
  // @@protoc_insertion_point(field_get:mgard.pb.ExplicitCubeGeometry.coordinates)
  return _internal_coordinates().Get(index);
}
inline void ExplicitCubeGeometry::set_coordinates(int index, double value) {
  _internal_mutable_coordinates()->Set(index, value);
  // @@protoc_insertion_point(field_set:mgard.pb.ExplicitCubeGeometry.coordinates)
}
inline void ExplicitCubeGeometry::add_coordinates(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _internal_mutable_coordinates()
      ->InternalAddWithArena<const ::google::protobuf::MessageLite*>(
          internal_visibility(), this, value);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_add:mgard.pb.ExplicitCubeGeometry.coordinates)
}
inline const ::google::protobuf::RepeatedField<double>& ExplicitCubeGeometry::coordinates() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:mgard.pb.ExplicitCubeGeometry.coordinates)
  return _internal_coordinates();
}
inline ::google::protobuf::RepeatedField<double>* PROTOBUF_NONNULL ExplicitCubeGeometry::mutable_coordinates()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_mutable_list:mgard.pb.ExplicitCubeGeometry.coordinates)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_coordinates();
}
inline const ::google::protobuf::RepeatedField<double>&
ExplicitCubeGeometry::_internal_coordinates() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.coordinates_;
}
inline ::google::protobuf::RepeatedField<double>* PROTOBUF_NONNULL
ExplicitCubeGeometry::_internal_mutable_coordinates() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.coordinates_;
}

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

// Domain

// .mgard.pb.Domain.Topology topology = 1;
inline void Domain::clear_topology() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.topology_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline ::mgard::pb::Domain_Topology Domain::topology() const {
  // @@protoc_insertion_point(field_get:mgard.pb.Domain.topology)
  return _internal_topology();
}
inline void Domain::set_topology(::mgard::pb::Domain_Topology value) {
  _internal_set_topology(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_set:mgard.pb.Domain.topology)
}
inline ::mgard::pb::Domain_Topology Domain::_internal_topology() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::mgard::pb::Domain_Topology>(_impl_.topology_);
}
inline void Domain::_internal_set_topology(::mgard::pb::Domain_Topology value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.topology_ = value;
}

// .mgard.pb.CartesianGridTopology cartesian_grid_topology = 2;
inline bool Domain::has_cartesian_grid_topology() const {
  return topology_definition_case() == kCartesianGridTopology;
}
inline bool Domain::_internal_has_cartesian_grid_topology() const {
  return topology_definition_case() == kCartesianGridTopology;
}
inline void Domain::set_has_cartesian_grid_topology() {
  _impl_._oneof_case_[0] = kCartesianGridTopology;
}
inline void Domain::clear_cartesian_grid_topology() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (topology_definition_case() == kCartesianGridTopology) {
    if (GetArena() == nullptr) {
      delete _impl_.topology_definition_.cartesian_grid_topology_;
    } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) {
      ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.topology_definition_.cartesian_grid_topology_);
    }
    clear_has_topology_definition();
  }
}
inline ::mgard::pb::CartesianGridTopology* PROTOBUF_NULLABLE Domain::release_cartesian_grid_topology() {
  // @@protoc_insertion_point(field_release:mgard.pb.Domain.cartesian_grid_topology)
  if (topology_definition_case() == kCartesianGridTopology) {
    clear_has_topology_definition();
    auto* temp = _impl_.topology_definition_.cartesian_grid_topology_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.topology_definition_.cartesian_grid_topology_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::mgard::pb::CartesianGridTopology& Domain::_internal_cartesian_grid_topology() const {
  return topology_definition_case() == kCartesianGridTopology ? static_cast<const ::mgard::pb::CartesianGridTopology&>(*_impl_.topology_definition_.cartesian_grid_topology_)
                     : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::mgard::pb::CartesianGridTopology>(&::mgard::pb::CartesianGridTopology_globals_);
}
inline const ::mgard::pb::CartesianGridTopology& Domain::cartesian_grid_topology() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:mgard.pb.Domain.cartesian_grid_topology)
  return _internal_cartesian_grid_topology();
}
inline ::mgard::pb::CartesianGridTopology* PROTOBUF_NULLABLE Domain::unsafe_arena_release_cartesian_grid_topology() {
  // @@protoc_insertion_point(field_unsafe_arena_release:mgard.pb.Domain.cartesian_grid_topology)
  if (topology_definition_case() == kCartesianGridTopology) {
    clear_has_topology_definition();
    auto* temp = _impl_.topology_definition_.cartesian_grid_topology_;
    _impl_.topology_definition_.cartesian_grid_topology_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Domain::unsafe_arena_set_allocated_cartesian_grid_topology(
    ::mgard::pb::CartesianGridTopology* PROTOBUF_NULLABLE value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_topology_definition();
  if (value) {
    set_has_cartesian_grid_topology();
    _impl_.topology_definition_.cartesian_grid_topology_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mgard.pb.Domain.cartesian_grid_topology)
}
inline ::mgard::pb::CartesianGridTopology* PROTOBUF_NONNULL Domain::_internal_mutable_cartesian_grid_topology() {
  if (topology_definition_case() != kCartesianGridTopology) {
    clear_topology_definition();
    set_has_cartesian_grid_topology();
    _impl_.topology_definition_.cartesian_grid_topology_ = Super_::DefaultConstruct<::mgard::pb::CartesianGridTopology>(GetArena());
  }
  return _impl_.topology_definition_.cartesian_grid_topology_;
}
inline ::mgard::pb::CartesianGridTopology* PROTOBUF_NONNULL Domain::mutable_cartesian_grid_topology()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::mgard::pb::CartesianGridTopology* _msg = _internal_mutable_cartesian_grid_topology();
  // @@protoc_insertion_point(field_mutable:mgard.pb.Domain.cartesian_grid_topology)
  return _msg;
}

// .mgard.pb.Domain.Geometry geometry = 3;
inline void Domain::clear_geometry() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.geometry_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline ::mgard::pb::Domain_Geometry Domain::geometry() const {
  // @@protoc_insertion_point(field_get:mgard.pb.Domain.geometry)
  return _internal_geometry();
}
inline void Domain::set_geometry(::mgard::pb::Domain_Geometry value) {
  _internal_set_geometry(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_set:mgard.pb.Domain.geometry)
}
inline ::mgard::pb::Domain_Geometry Domain::_internal_geometry() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::mgard::pb::Domain_Geometry>(_impl_.geometry_);
}
inline void Domain::_internal_set_geometry(::mgard::pb::Domain_Geometry value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.geometry_ = value;
}

// .mgard.pb.ExplicitCubeGeometry explicit_cube_geometry = 4;
inline bool Domain::has_explicit_cube_geometry() const {
  return geometry_definition_case() == kExplicitCubeGeometry;
}
inline bool Domain::_internal_has_explicit_cube_geometry() const {
  return geometry_definition_case() == kExplicitCubeGeometry;
}
inline void Domain::set_has_explicit_cube_geometry() {
  _impl_._oneof_case_[1] = kExplicitCubeGeometry;
}
inline void Domain::clear_explicit_cube_geometry() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (geometry_definition_case() == kExplicitCubeGeometry) {
    if (GetArena() == nullptr) {
      delete _impl_.geometry_definition_.explicit_cube_geometry_;
    } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) {
      ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.geometry_definition_.explicit_cube_geometry_);
    }
    clear_has_geometry_definition();
  }
}
inline ::mgard::pb::ExplicitCubeGeometry* PROTOBUF_NULLABLE Domain::release_explicit_cube_geometry() {
  // @@protoc_insertion_point(field_release:mgard.pb.Domain.explicit_cube_geometry)
  if (geometry_definition_case() == kExplicitCubeGeometry) {
    clear_has_geometry_definition();
    auto* temp = _impl_.geometry_definition_.explicit_cube_geometry_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.geometry_definition_.explicit_cube_geometry_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::mgard::pb::ExplicitCubeGeometry& Domain::_internal_explicit_cube_geometry() const {
  return geometry_definition_case() == kExplicitCubeGeometry ? static_cast<const ::mgard::pb::ExplicitCubeGeometry&>(*_impl_.geometry_definition_.explicit_cube_geometry_)
                     : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::mgard::pb::ExplicitCubeGeometry>(&::mgard::pb::ExplicitCubeGeometry_globals_);
}
inline const ::mgard::pb::ExplicitCubeGeometry& Domain::explicit_cube_geometry() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:mgard.pb.Domain.explicit_cube_geometry)
  return _internal_explicit_cube_geometry();
}
inline ::mgard::pb::ExplicitCubeGeometry* PROTOBUF_NULLABLE Domain::unsafe_arena_release_explicit_cube_geometry() {
  // @@protoc_insertion_point(field_unsafe_arena_release:mgard.pb.Domain.explicit_cube_geometry)
  if (geometry_definition_case() == kExplicitCubeGeometry) {
    clear_has_geometry_definition();
    auto* temp = _impl_.geometry_definition_.explicit_cube_geometry_;
    _impl_.geometry_definition_.explicit_cube_geometry_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Domain::unsafe_arena_set_allocated_explicit_cube_geometry(
    ::mgard::pb::ExplicitCubeGeometry* PROTOBUF_NULLABLE value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_geometry_definition();
  if (value) {
    set_has_explicit_cube_geometry();
    _impl_.geometry_definition_.explicit_cube_geometry_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mgard.pb.Domain.explicit_cube_geometry)
}
inline ::mgard::pb::ExplicitCubeGeometry* PROTOBUF_NONNULL Domain::_internal_mutable_explicit_cube_geometry() {
  if (geometry_definition_case() != kExplicitCubeGeometry) {
    clear_geometry_definition();
    set_has_explicit_cube_geometry();
    _impl_.geometry_definition_.explicit_cube_geometry_ = Super_::DefaultConstruct<::mgard::pb::ExplicitCubeGeometry>(GetArena());
  }
  return _impl_.geometry_definition_.explicit_cube_geometry_;
}
inline ::mgard::pb::ExplicitCubeGeometry* PROTOBUF_NONNULL Domain::mutable_explicit_cube_geometry()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::mgard::pb::ExplicitCubeGeometry* _msg = _internal_mutable_explicit_cube_geometry();
  // @@protoc_insertion_point(field_mutable:mgard.pb.Domain.explicit_cube_geometry)
  return _msg;
}

// string explicit_cube_filename = 5;
inline bool Domain::has_explicit_cube_filename() const {
  return geometry_definition_case() == kExplicitCubeFilename;
}
inline void Domain::set_has_explicit_cube_filename() {
  _impl_._oneof_case_[1] = kExplicitCubeFilename;
}
inline void Domain::clear_explicit_cube_filename() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (geometry_definition_case() == kExplicitCubeFilename) {
    _impl_.geometry_definition_.explicit_cube_filename_.Destroy();
    clear_has_geometry_definition();
  }
}
inline const ::std::string& Domain::explicit_cube_filename() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:mgard.pb.Domain.explicit_cube_filename)
  return _internal_explicit_cube_filename();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void Domain::set_explicit_cube_filename(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (geometry_definition_case() != kExplicitCubeFilename) {
    clear_geometry_definition();

    set_has_explicit_cube_filename();
    _impl_.geometry_definition_.explicit_cube_filename_.InitDefault();
  }
  _impl_.geometry_definition_.explicit_cube_filename_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:mgard.pb.Domain.explicit_cube_filename)
}
inline ::std::string* PROTOBUF_NONNULL Domain::mutable_explicit_cube_filename()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  if (geometry_definition_case() != kExplicitCubeFilename) {
    clear_geometry_definition();

    set_has_explicit_cube_filename();
    _impl_.geometry_definition_.explicit_cube_filename_.InitDefault();
  }
  ::std::string* _s = _internal_mutable_explicit_cube_filename();
  // @@protoc_insertion_point(field_mutable:mgard.pb.Domain.explicit_cube_filename)
  return _s;
}
inline const ::std::string& Domain::_internal_explicit_cube_filename() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  if (geometry_definition_case() != kExplicitCubeFilename) {
    return ::google::protobuf::internal::GetEmptyStringAlreadyInited();
  }
  return _impl_.geometry_definition_.explicit_cube_filename_.Get();
}
inline void Domain::_internal_set_explicit_cube_filename(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.geometry_definition_.explicit_cube_filename_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL Domain::_internal_mutable_explicit_cube_filename() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.geometry_definition_.explicit_cube_filename_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE Domain::release_explicit_cube_filename() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:mgard.pb.Domain.explicit_cube_filename)
  if (geometry_definition_case() != kExplicitCubeFilename) {
    return nullptr;
  }
  clear_has_geometry_definition();
  return _impl_.geometry_definition_.explicit_cube_filename_.Release();
}
inline void Domain::set_allocated_explicit_cube_filename(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (has_geometry_definition()) {
    clear_geometry_definition();
  }
  if (value != nullptr) {
    set_has_explicit_cube_filename();
    _impl_.geometry_definition_.explicit_cube_filename_.InitAllocated(value, GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:mgard.pb.Domain.explicit_cube_filename)
}

inline bool Domain::has_topology_definition() const {
  return topology_definition_case() != TOPOLOGY_DEFINITION_NOT_SET;
}
inline void Domain::clear_has_topology_definition() {
  _impl_._oneof_case_[0] = TOPOLOGY_DEFINITION_NOT_SET;
}
inline bool Domain::has_geometry_definition() const {
  return geometry_definition_case() != GEOMETRY_DEFINITION_NOT_SET;
}
inline void Domain::clear_has_geometry_definition() {
  _impl_._oneof_case_[1] = GEOMETRY_DEFINITION_NOT_SET;
}
inline Domain::TopologyDefinitionCase Domain::topology_definition_case() const {
  return Domain::TopologyDefinitionCase(_impl_._oneof_case_[0]);
}
inline Domain::GeometryDefinitionCase Domain::geometry_definition_case() const {
  return Domain::GeometryDefinitionCase(_impl_._oneof_case_[1]);
}
// -------------------------------------------------------------------

// Dataset

// .mgard.pb.Dataset.Type type = 1;
inline void Dataset::clear_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.type_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline ::mgard::pb::Dataset_Type Dataset::type() const {
  // @@protoc_insertion_point(field_get:mgard.pb.Dataset.type)
  return _internal_type();
}
inline void Dataset::set_type(::mgard::pb::Dataset_Type value) {
  _internal_set_type(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_set:mgard.pb.Dataset.type)
}
inline ::mgard::pb::Dataset_Type Dataset::_internal_type() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::mgard::pb::Dataset_Type>(_impl_.type_);
}
inline void Dataset::_internal_set_type(::mgard::pb::Dataset_Type value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.type_ = value;
}

// uint64 dimension = 2;
inline void Dataset::clear_dimension() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.dimension_ = ::uint64_t{0u};
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline ::uint64_t Dataset::dimension() const {
  // @@protoc_insertion_point(field_get:mgard.pb.Dataset.dimension)
  return _internal_dimension();
}
inline void Dataset::set_dimension(::uint64_t value) {
  _internal_set_dimension(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_set:mgard.pb.Dataset.dimension)
}
inline ::uint64_t Dataset::_internal_dimension() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.dimension_;
}
inline void Dataset::_internal_set_dimension(::uint64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.dimension_ = value;
}

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

// ErrorControl

// .mgard.pb.ErrorControl.Mode mode = 1;
inline void ErrorControl::clear_mode() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.mode_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline ::mgard::pb::ErrorControl_Mode ErrorControl::mode() const {
  // @@protoc_insertion_point(field_get:mgard.pb.ErrorControl.mode)
  return _internal_mode();
}
inline void ErrorControl::set_mode(::mgard::pb::ErrorControl_Mode value) {
  _internal_set_mode(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_set:mgard.pb.ErrorControl.mode)
}
inline ::mgard::pb::ErrorControl_Mode ErrorControl::_internal_mode() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::mgard::pb::ErrorControl_Mode>(_impl_.mode_);
}
inline void ErrorControl::_internal_set_mode(::mgard::pb::ErrorControl_Mode value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.mode_ = value;
}

// .mgard.pb.ErrorControl.Norm norm = 2;
inline void ErrorControl::clear_norm() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.norm_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline ::mgard::pb::ErrorControl_Norm ErrorControl::norm() const {
  // @@protoc_insertion_point(field_get:mgard.pb.ErrorControl.norm)
  return _internal_norm();
}
inline void ErrorControl::set_norm(::mgard::pb::ErrorControl_Norm value) {
  _internal_set_norm(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_set:mgard.pb.ErrorControl.norm)
}
inline ::mgard::pb::ErrorControl_Norm ErrorControl::_internal_norm() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::mgard::pb::ErrorControl_Norm>(_impl_.norm_);
}
inline void ErrorControl::_internal_set_norm(::mgard::pb::ErrorControl_Norm value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.norm_ = value;
}

// double s = 3;
inline void ErrorControl::clear_s() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.s_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline double ErrorControl::s() const {
  // @@protoc_insertion_point(field_get:mgard.pb.ErrorControl.s)
  return _internal_s();
}
inline void ErrorControl::set_s(double value) {
  _internal_set_s(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_set:mgard.pb.ErrorControl.s)
}
inline double ErrorControl::_internal_s() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.s_;
}
inline void ErrorControl::_internal_set_s(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.s_ = value;
}

// double norm_of_original_data = 4;
inline void ErrorControl::clear_norm_of_original_data() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.norm_of_original_data_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
}
inline double ErrorControl::norm_of_original_data() const {
  // @@protoc_insertion_point(field_get:mgard.pb.ErrorControl.norm_of_original_data)
  return _internal_norm_of_original_data();
}
inline void ErrorControl::set_norm_of_original_data(double value) {
  _internal_set_norm_of_original_data(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  // @@protoc_insertion_point(field_set:mgard.pb.ErrorControl.norm_of_original_data)
}
inline double ErrorControl::_internal_norm_of_original_data() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.norm_of_original_data_;
}
inline void ErrorControl::_internal_set_norm_of_original_data(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.norm_of_original_data_ = value;
}

// double tolerance = 5;
inline void ErrorControl::clear_tolerance() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.tolerance_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
}
inline double ErrorControl::tolerance() const {
  // @@protoc_insertion_point(field_get:mgard.pb.ErrorControl.tolerance)
  return _internal_tolerance();
}
inline void ErrorControl::set_tolerance(double value) {
  _internal_set_tolerance(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  // @@protoc_insertion_point(field_set:mgard.pb.ErrorControl.tolerance)
}
inline double ErrorControl::_internal_tolerance() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.tolerance_;
}
inline void ErrorControl::_internal_set_tolerance(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.tolerance_ = value;
}

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

// DomainDecomposition

// .mgard.pb.DomainDecomposition.Method method = 1;
inline void DomainDecomposition::clear_method() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.method_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline ::mgard::pb::DomainDecomposition_Method DomainDecomposition::method() const {
  // @@protoc_insertion_point(field_get:mgard.pb.DomainDecomposition.method)
  return _internal_method();
}
inline void DomainDecomposition::set_method(::mgard::pb::DomainDecomposition_Method value) {
  _internal_set_method(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_set:mgard.pb.DomainDecomposition.method)
}
inline ::mgard::pb::DomainDecomposition_Method DomainDecomposition::_internal_method() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::mgard::pb::DomainDecomposition_Method>(_impl_.method_);
}
inline void DomainDecomposition::_internal_set_method(::mgard::pb::DomainDecomposition_Method value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.method_ = value;
}

// uint64 decomposition_dimension = 2;
inline void DomainDecomposition::clear_decomposition_dimension() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.decomposition_dimension_ = ::uint64_t{0u};
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline ::uint64_t DomainDecomposition::decomposition_dimension() const {
  // @@protoc_insertion_point(field_get:mgard.pb.DomainDecomposition.decomposition_dimension)
  return _internal_decomposition_dimension();
}
inline void DomainDecomposition::set_decomposition_dimension(::uint64_t value) {
  _internal_set_decomposition_dimension(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_set:mgard.pb.DomainDecomposition.decomposition_dimension)
}
inline ::uint64_t DomainDecomposition::_internal_decomposition_dimension() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.decomposition_dimension_;
}
inline void DomainDecomposition::_internal_set_decomposition_dimension(::uint64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.decomposition_dimension_ = value;
}

// uint64 decomposition_size = 3;
inline void DomainDecomposition::clear_decomposition_size() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.decomposition_size_ = ::uint64_t{0u};
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline ::uint64_t DomainDecomposition::decomposition_size() const {
  // @@protoc_insertion_point(field_get:mgard.pb.DomainDecomposition.decomposition_size)
  return _internal_decomposition_size();
}
inline void DomainDecomposition::set_decomposition_size(::uint64_t value) {
  _internal_set_decomposition_size(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_set:mgard.pb.DomainDecomposition.decomposition_size)
}
inline ::uint64_t DomainDecomposition::_internal_decomposition_size() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.decomposition_size_;
}
inline void DomainDecomposition::_internal_set_decomposition_size(::uint64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.decomposition_size_ = value;
}

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

// FunctionDecomposition

// .mgard.pb.FunctionDecomposition.Transform transform = 1;
inline void FunctionDecomposition::clear_transform() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.transform_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline ::mgard::pb::FunctionDecomposition_Transform FunctionDecomposition::transform() const {
  // @@protoc_insertion_point(field_get:mgard.pb.FunctionDecomposition.transform)
  return _internal_transform();
}
inline void FunctionDecomposition::set_transform(::mgard::pb::FunctionDecomposition_Transform value) {
  _internal_set_transform(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_set:mgard.pb.FunctionDecomposition.transform)
}
inline ::mgard::pb::FunctionDecomposition_Transform FunctionDecomposition::_internal_transform() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::mgard::pb::FunctionDecomposition_Transform>(_impl_.transform_);
}
inline void FunctionDecomposition::_internal_set_transform(::mgard::pb::FunctionDecomposition_Transform value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.transform_ = value;
}

// .mgard.pb.FunctionDecomposition.Hierarchy hierarchy = 2;
inline void FunctionDecomposition::clear_hierarchy() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.hierarchy_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline ::mgard::pb::FunctionDecomposition_Hierarchy FunctionDecomposition::hierarchy() const {
  // @@protoc_insertion_point(field_get:mgard.pb.FunctionDecomposition.hierarchy)
  return _internal_hierarchy();
}
inline void FunctionDecomposition::set_hierarchy(::mgard::pb::FunctionDecomposition_Hierarchy value) {
  _internal_set_hierarchy(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_set:mgard.pb.FunctionDecomposition.hierarchy)
}
inline ::mgard::pb::FunctionDecomposition_Hierarchy FunctionDecomposition::_internal_hierarchy() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::mgard::pb::FunctionDecomposition_Hierarchy>(_impl_.hierarchy_);
}
inline void FunctionDecomposition::_internal_set_hierarchy(::mgard::pb::FunctionDecomposition_Hierarchy value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.hierarchy_ = value;
}

// uint64 L_target = 3;
inline void FunctionDecomposition::clear_l_target() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.l_target_ = ::uint64_t{0u};
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline ::uint64_t FunctionDecomposition::l_target() const {
  // @@protoc_insertion_point(field_get:mgard.pb.FunctionDecomposition.L_target)
  return _internal_l_target();
}
inline void FunctionDecomposition::set_l_target(::uint64_t value) {
  _internal_set_l_target(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_set:mgard.pb.FunctionDecomposition.L_target)
}
inline ::uint64_t FunctionDecomposition::_internal_l_target() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.l_target_;
}
inline void FunctionDecomposition::_internal_set_l_target(::uint64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.l_target_ = value;
}

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

// Quantization

// .mgard.pb.Quantization.Method method = 1;
inline void Quantization::clear_method() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.method_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline ::mgard::pb::Quantization_Method Quantization::method() const {
  // @@protoc_insertion_point(field_get:mgard.pb.Quantization.method)
  return _internal_method();
}
inline void Quantization::set_method(::mgard::pb::Quantization_Method value) {
  _internal_set_method(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_set:mgard.pb.Quantization.method)
}
inline ::mgard::pb::Quantization_Method Quantization::_internal_method() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::mgard::pb::Quantization_Method>(_impl_.method_);
}
inline void Quantization::_internal_set_method(::mgard::pb::Quantization_Method value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.method_ = value;
}

// .mgard.pb.Quantization.BinWidths bin_widths = 2;
inline void Quantization::clear_bin_widths() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.bin_widths_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline ::mgard::pb::Quantization_BinWidths Quantization::bin_widths() const {
  // @@protoc_insertion_point(field_get:mgard.pb.Quantization.bin_widths)
  return _internal_bin_widths();
}
inline void Quantization::set_bin_widths(::mgard::pb::Quantization_BinWidths value) {
  _internal_set_bin_widths(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_set:mgard.pb.Quantization.bin_widths)
}
inline ::mgard::pb::Quantization_BinWidths Quantization::_internal_bin_widths() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::mgard::pb::Quantization_BinWidths>(_impl_.bin_widths_);
}
inline void Quantization::_internal_set_bin_widths(::mgard::pb::Quantization_BinWidths value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.bin_widths_ = value;
}

// .mgard.pb.Quantization.Type type = 3;
inline void Quantization::clear_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.type_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline ::mgard::pb::Quantization_Type Quantization::type() const {
  // @@protoc_insertion_point(field_get:mgard.pb.Quantization.type)
  return _internal_type();
}
inline void Quantization::set_type(::mgard::pb::Quantization_Type value) {
  _internal_set_type(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_set:mgard.pb.Quantization.type)
}
inline ::mgard::pb::Quantization_Type Quantization::_internal_type() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::mgard::pb::Quantization_Type>(_impl_.type_);
}
inline void Quantization::_internal_set_type(::mgard::pb::Quantization_Type value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.type_ = value;
}

// bool big_endian = 4;
inline void Quantization::clear_big_endian() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.big_endian_ = false;
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
}
inline bool Quantization::big_endian() const {
  // @@protoc_insertion_point(field_get:mgard.pb.Quantization.big_endian)
  return _internal_big_endian();
}
inline void Quantization::set_big_endian(bool value) {
  _internal_set_big_endian(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  // @@protoc_insertion_point(field_set:mgard.pb.Quantization.big_endian)
}
inline bool Quantization::_internal_big_endian() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.big_endian_;
}
inline void Quantization::_internal_set_big_endian(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.big_endian_ = value;
}

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

// BitplaneEncoding

// .mgard.pb.BitplaneEncoding.Method method = 1;
inline void BitplaneEncoding::clear_method() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.method_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline ::mgard::pb::BitplaneEncoding_Method BitplaneEncoding::method() const {
  // @@protoc_insertion_point(field_get:mgard.pb.BitplaneEncoding.method)
  return _internal_method();
}
inline void BitplaneEncoding::set_method(::mgard::pb::BitplaneEncoding_Method value) {
  _internal_set_method(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_set:mgard.pb.BitplaneEncoding.method)
}
inline ::mgard::pb::BitplaneEncoding_Method BitplaneEncoding::_internal_method() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::mgard::pb::BitplaneEncoding_Method>(_impl_.method_);
}
inline void BitplaneEncoding::_internal_set_method(::mgard::pb::BitplaneEncoding_Method value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.method_ = value;
}

// .mgard.pb.BitplaneEncoding.Type type = 2;
inline void BitplaneEncoding::clear_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.type_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline ::mgard::pb::BitplaneEncoding_Type BitplaneEncoding::type() const {
  // @@protoc_insertion_point(field_get:mgard.pb.BitplaneEncoding.type)
  return _internal_type();
}
inline void BitplaneEncoding::set_type(::mgard::pb::BitplaneEncoding_Type value) {
  _internal_set_type(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_set:mgard.pb.BitplaneEncoding.type)
}
inline ::mgard::pb::BitplaneEncoding_Type BitplaneEncoding::_internal_type() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::mgard::pb::BitplaneEncoding_Type>(_impl_.type_);
}
inline void BitplaneEncoding::_internal_set_type(::mgard::pb::BitplaneEncoding_Type value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.type_ = value;
}

// uint64 number_bitplanes = 3;
inline void BitplaneEncoding::clear_number_bitplanes() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.number_bitplanes_ = ::uint64_t{0u};
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline ::uint64_t BitplaneEncoding::number_bitplanes() const {
  // @@protoc_insertion_point(field_get:mgard.pb.BitplaneEncoding.number_bitplanes)
  return _internal_number_bitplanes();
}
inline void BitplaneEncoding::set_number_bitplanes(::uint64_t value) {
  _internal_set_number_bitplanes(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_set:mgard.pb.BitplaneEncoding.number_bitplanes)
}
inline ::uint64_t BitplaneEncoding::_internal_number_bitplanes() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.number_bitplanes_;
}
inline void BitplaneEncoding::_internal_set_number_bitplanes(::uint64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.number_bitplanes_ = value;
}

// bool big_endian = 4;
inline void BitplaneEncoding::clear_big_endian() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.big_endian_ = false;
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
}
inline bool BitplaneEncoding::big_endian() const {
  // @@protoc_insertion_point(field_get:mgard.pb.BitplaneEncoding.big_endian)
  return _internal_big_endian();
}
inline void BitplaneEncoding::set_big_endian(bool value) {
  _internal_set_big_endian(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  // @@protoc_insertion_point(field_set:mgard.pb.BitplaneEncoding.big_endian)
}
inline bool BitplaneEncoding::_internal_big_endian() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.big_endian_;
}
inline void BitplaneEncoding::_internal_set_big_endian(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.big_endian_ = value;
}

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

// Encoding

// .mgard.pb.Encoding.Preprocessor preprocessor = 1;
inline void Encoding::clear_preprocessor() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.preprocessor_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline ::mgard::pb::Encoding_Preprocessor Encoding::preprocessor() const {
  // @@protoc_insertion_point(field_get:mgard.pb.Encoding.preprocessor)
  return _internal_preprocessor();
}
inline void Encoding::set_preprocessor(::mgard::pb::Encoding_Preprocessor value) {
  _internal_set_preprocessor(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_set:mgard.pb.Encoding.preprocessor)
}
inline ::mgard::pb::Encoding_Preprocessor Encoding::_internal_preprocessor() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::mgard::pb::Encoding_Preprocessor>(_impl_.preprocessor_);
}
inline void Encoding::_internal_set_preprocessor(::mgard::pb::Encoding_Preprocessor value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.preprocessor_ = value;
}

// .mgard.pb.Encoding.Compressor compressor = 2;
inline void Encoding::clear_compressor() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.compressor_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline ::mgard::pb::Encoding_Compressor Encoding::compressor() const {
  // @@protoc_insertion_point(field_get:mgard.pb.Encoding.compressor)
  return _internal_compressor();
}
inline void Encoding::set_compressor(::mgard::pb::Encoding_Compressor value) {
  _internal_set_compressor(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_set:mgard.pb.Encoding.compressor)
}
inline ::mgard::pb::Encoding_Compressor Encoding::_internal_compressor() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::mgard::pb::Encoding_Compressor>(_impl_.compressor_);
}
inline void Encoding::_internal_set_compressor(::mgard::pb::Encoding_Compressor value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.compressor_ = value;
}

// uint64 huffman_dictionary_size = 3;
inline void Encoding::clear_huffman_dictionary_size() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.huffman_dictionary_size_ = ::uint64_t{0u};
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline ::uint64_t Encoding::huffman_dictionary_size() const {
  // @@protoc_insertion_point(field_get:mgard.pb.Encoding.huffman_dictionary_size)
  return _internal_huffman_dictionary_size();
}
inline void Encoding::set_huffman_dictionary_size(::uint64_t value) {
  _internal_set_huffman_dictionary_size(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_set:mgard.pb.Encoding.huffman_dictionary_size)
}
inline ::uint64_t Encoding::_internal_huffman_dictionary_size() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.huffman_dictionary_size_;
}
inline void Encoding::_internal_set_huffman_dictionary_size(::uint64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.huffman_dictionary_size_ = value;
}

// uint64 huffman_block_size = 4;
inline void Encoding::clear_huffman_block_size() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.huffman_block_size_ = ::uint64_t{0u};
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
}
inline ::uint64_t Encoding::huffman_block_size() const {
  // @@protoc_insertion_point(field_get:mgard.pb.Encoding.huffman_block_size)
  return _internal_huffman_block_size();
}
inline void Encoding::set_huffman_block_size(::uint64_t value) {
  _internal_set_huffman_block_size(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  // @@protoc_insertion_point(field_set:mgard.pb.Encoding.huffman_block_size)
}
inline ::uint64_t Encoding::_internal_huffman_block_size() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.huffman_block_size_;
}
inline void Encoding::_internal_set_huffman_block_size(::uint64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.huffman_block_size_ = value;
}

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

// Device

// .mgard.pb.Device.Backend backend = 1;
inline void Device::clear_backend() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.backend_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline ::mgard::pb::Device_Backend Device::backend() const {
  // @@protoc_insertion_point(field_get:mgard.pb.Device.backend)
  return _internal_backend();
}
inline void Device::set_backend(::mgard::pb::Device_Backend value) {
  _internal_set_backend(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_set:mgard.pb.Device.backend)
}
inline ::mgard::pb::Device_Backend Device::_internal_backend() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::mgard::pb::Device_Backend>(_impl_.backend_);
}
inline void Device::_internal_set_backend(::mgard::pb::Device_Backend value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.backend_ = value;
}

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

// Header

// .mgard.pb.VersionNumber mgard_version = 2;
inline bool Header::has_mgard_version() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  PROTOBUF_ASSUME(!value || _impl_.mgard_version_ != nullptr);
  return value;
}
inline void Header::clear_mgard_version() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.mgard_version_ != nullptr) _impl_.mgard_version_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline const ::mgard::pb::VersionNumber& Header::_internal_mgard_version() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::mgard::pb::VersionNumber* p = _impl_.mgard_version_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::mgard::pb::VersionNumber>(&::mgard::pb::VersionNumber_globals_);
}
inline const ::mgard::pb::VersionNumber& Header::mgard_version() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:mgard.pb.Header.mgard_version)
  return _internal_mgard_version();
}
inline void Header::unsafe_arena_set_allocated_mgard_version(
    ::mgard::pb::VersionNumber* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.mgard_version_);
  }
  _impl_.mgard_version_ = reinterpret_cast<::mgard::pb::VersionNumber*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mgard.pb.Header.mgard_version)
}
inline ::mgard::pb::VersionNumber* PROTOBUF_NULLABLE Header::release_mgard_version() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::mgard::pb::VersionNumber* released = _impl_.mgard_version_;
  _impl_.mgard_version_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::mgard::pb::VersionNumber* PROTOBUF_NULLABLE Header::unsafe_arena_release_mgard_version() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:mgard.pb.Header.mgard_version)

  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::mgard::pb::VersionNumber* temp = _impl_.mgard_version_;
  _impl_.mgard_version_ = nullptr;
  return temp;
}
inline ::mgard::pb::VersionNumber* PROTOBUF_NONNULL Header::_internal_mutable_mgard_version() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.mgard_version_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::mgard::pb::VersionNumber>(GetArena());
    _impl_.mgard_version_ = reinterpret_cast<::mgard::pb::VersionNumber*>(p);
  }
  return _impl_.mgard_version_;
}
inline ::mgard::pb::VersionNumber* PROTOBUF_NONNULL Header::mutable_mgard_version()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::mgard::pb::VersionNumber* _msg = _internal_mutable_mgard_version();
  // @@protoc_insertion_point(field_mutable:mgard.pb.Header.mgard_version)
  return _msg;
}
inline void Header::set_allocated_mgard_version(::mgard::pb::VersionNumber* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.mgard_version_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = value->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }

  _impl_.mgard_version_ = reinterpret_cast<::mgard::pb::VersionNumber*>(value);
  // @@protoc_insertion_point(field_set_allocated:mgard.pb.Header.mgard_version)
}

// .mgard.pb.VersionNumber file_format_version = 3;
inline bool Header::has_file_format_version() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  PROTOBUF_ASSUME(!value || _impl_.file_format_version_ != nullptr);
  return value;
}
inline void Header::clear_file_format_version() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.file_format_version_ != nullptr) _impl_.file_format_version_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline const ::mgard::pb::VersionNumber& Header::_internal_file_format_version() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::mgard::pb::VersionNumber* p = _impl_.file_format_version_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::mgard::pb::VersionNumber>(&::mgard::pb::VersionNumber_globals_);
}
inline const ::mgard::pb::VersionNumber& Header::file_format_version() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:mgard.pb.Header.file_format_version)
  return _internal_file_format_version();
}
inline void Header::unsafe_arena_set_allocated_file_format_version(
    ::mgard::pb::VersionNumber* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.file_format_version_);
  }
  _impl_.file_format_version_ = reinterpret_cast<::mgard::pb::VersionNumber*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mgard.pb.Header.file_format_version)
}
inline ::mgard::pb::VersionNumber* PROTOBUF_NULLABLE Header::release_file_format_version() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::mgard::pb::VersionNumber* released = _impl_.file_format_version_;
  _impl_.file_format_version_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::mgard::pb::VersionNumber* PROTOBUF_NULLABLE Header::unsafe_arena_release_file_format_version() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:mgard.pb.Header.file_format_version)

  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::mgard::pb::VersionNumber* temp = _impl_.file_format_version_;
  _impl_.file_format_version_ = nullptr;
  return temp;
}
inline ::mgard::pb::VersionNumber* PROTOBUF_NONNULL Header::_internal_mutable_file_format_version() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.file_format_version_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::mgard::pb::VersionNumber>(GetArena());
    _impl_.file_format_version_ = reinterpret_cast<::mgard::pb::VersionNumber*>(p);
  }
  return _impl_.file_format_version_;
}
inline ::mgard::pb::VersionNumber* PROTOBUF_NONNULL Header::mutable_file_format_version()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::mgard::pb::VersionNumber* _msg = _internal_mutable_file_format_version();
  // @@protoc_insertion_point(field_mutable:mgard.pb.Header.file_format_version)
  return _msg;
}
inline void Header::set_allocated_file_format_version(::mgard::pb::VersionNumber* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.file_format_version_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = value->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  }

  _impl_.file_format_version_ = reinterpret_cast<::mgard::pb::VersionNumber*>(value);
  // @@protoc_insertion_point(field_set_allocated:mgard.pb.Header.file_format_version)
}

// .mgard.pb.Domain domain = 4;
inline bool Header::has_domain() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U);
  PROTOBUF_ASSUME(!value || _impl_.domain_ != nullptr);
  return value;
}
inline void Header::clear_domain() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.domain_ != nullptr) _impl_.domain_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline const ::mgard::pb::Domain& Header::_internal_domain() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::mgard::pb::Domain* p = _impl_.domain_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::mgard::pb::Domain>(&::mgard::pb::Domain_globals_);
}
inline const ::mgard::pb::Domain& Header::domain() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:mgard.pb.Header.domain)
  return _internal_domain();
}
inline void Header::unsafe_arena_set_allocated_domain(
    ::mgard::pb::Domain* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.domain_);
  }
  _impl_.domain_ = reinterpret_cast<::mgard::pb::Domain*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mgard.pb.Header.domain)
}
inline ::mgard::pb::Domain* PROTOBUF_NULLABLE Header::release_domain() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::mgard::pb::Domain* released = _impl_.domain_;
  _impl_.domain_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::mgard::pb::Domain* PROTOBUF_NULLABLE Header::unsafe_arena_release_domain() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:mgard.pb.Header.domain)

  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::mgard::pb::Domain* temp = _impl_.domain_;
  _impl_.domain_ = nullptr;
  return temp;
}
inline ::mgard::pb::Domain* PROTOBUF_NONNULL Header::_internal_mutable_domain() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.domain_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::mgard::pb::Domain>(GetArena());
    _impl_.domain_ = reinterpret_cast<::mgard::pb::Domain*>(p);
  }
  return _impl_.domain_;
}
inline ::mgard::pb::Domain* PROTOBUF_NONNULL Header::mutable_domain()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::mgard::pb::Domain* _msg = _internal_mutable_domain();
  // @@protoc_insertion_point(field_mutable:mgard.pb.Header.domain)
  return _msg;
}
inline void Header::set_allocated_domain(::mgard::pb::Domain* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.domain_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = value->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  }

  _impl_.domain_ = reinterpret_cast<::mgard::pb::Domain*>(value);
  // @@protoc_insertion_point(field_set_allocated:mgard.pb.Header.domain)
}

// .mgard.pb.Dataset dataset = 5;
inline bool Header::has_dataset() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000008U);
  PROTOBUF_ASSUME(!value || _impl_.dataset_ != nullptr);
  return value;
}
inline void Header::clear_dataset() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.dataset_ != nullptr) _impl_.dataset_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
}
inline const ::mgard::pb::Dataset& Header::_internal_dataset() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::mgard::pb::Dataset* p = _impl_.dataset_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::mgard::pb::Dataset>(&::mgard::pb::Dataset_globals_);
}
inline const ::mgard::pb::Dataset& Header::dataset() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:mgard.pb.Header.dataset)
  return _internal_dataset();
}
inline void Header::unsafe_arena_set_allocated_dataset(
    ::mgard::pb::Dataset* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.dataset_);
  }
  _impl_.dataset_ = reinterpret_cast<::mgard::pb::Dataset*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mgard.pb.Header.dataset)
}
inline ::mgard::pb::Dataset* PROTOBUF_NULLABLE Header::release_dataset() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  ::mgard::pb::Dataset* released = _impl_.dataset_;
  _impl_.dataset_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::mgard::pb::Dataset* PROTOBUF_NULLABLE Header::unsafe_arena_release_dataset() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:mgard.pb.Header.dataset)

  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  ::mgard::pb::Dataset* temp = _impl_.dataset_;
  _impl_.dataset_ = nullptr;
  return temp;
}
inline ::mgard::pb::Dataset* PROTOBUF_NONNULL Header::_internal_mutable_dataset() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.dataset_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::mgard::pb::Dataset>(GetArena());
    _impl_.dataset_ = reinterpret_cast<::mgard::pb::Dataset*>(p);
  }
  return _impl_.dataset_;
}
inline ::mgard::pb::Dataset* PROTOBUF_NONNULL Header::mutable_dataset()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  ::mgard::pb::Dataset* _msg = _internal_mutable_dataset();
  // @@protoc_insertion_point(field_mutable:mgard.pb.Header.dataset)
  return _msg;
}
inline void Header::set_allocated_dataset(::mgard::pb::Dataset* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.dataset_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = value->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  }

  _impl_.dataset_ = reinterpret_cast<::mgard::pb::Dataset*>(value);
  // @@protoc_insertion_point(field_set_allocated:mgard.pb.Header.dataset)
}

// .mgard.pb.ErrorControl error_control = 6;
inline bool Header::has_error_control() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000010U);
  PROTOBUF_ASSUME(!value || _impl_.error_control_ != nullptr);
  return value;
}
inline void Header::clear_error_control() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.error_control_ != nullptr) _impl_.error_control_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
}
inline const ::mgard::pb::ErrorControl& Header::_internal_error_control() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::mgard::pb::ErrorControl* p = _impl_.error_control_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::mgard::pb::ErrorControl>(&::mgard::pb::ErrorControl_globals_);
}
inline const ::mgard::pb::ErrorControl& Header::error_control() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:mgard.pb.Header.error_control)
  return _internal_error_control();
}
inline void Header::unsafe_arena_set_allocated_error_control(
    ::mgard::pb::ErrorControl* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.error_control_);
  }
  _impl_.error_control_ = reinterpret_cast<::mgard::pb::ErrorControl*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mgard.pb.Header.error_control)
}
inline ::mgard::pb::ErrorControl* PROTOBUF_NULLABLE Header::release_error_control() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
  ::mgard::pb::ErrorControl* released = _impl_.error_control_;
  _impl_.error_control_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::mgard::pb::ErrorControl* PROTOBUF_NULLABLE Header::unsafe_arena_release_error_control() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:mgard.pb.Header.error_control)

  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
  ::mgard::pb::ErrorControl* temp = _impl_.error_control_;
  _impl_.error_control_ = nullptr;
  return temp;
}
inline ::mgard::pb::ErrorControl* PROTOBUF_NONNULL Header::_internal_mutable_error_control() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.error_control_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::mgard::pb::ErrorControl>(GetArena());
    _impl_.error_control_ = reinterpret_cast<::mgard::pb::ErrorControl*>(p);
  }
  return _impl_.error_control_;
}
inline ::mgard::pb::ErrorControl* PROTOBUF_NONNULL Header::mutable_error_control()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  ::mgard::pb::ErrorControl* _msg = _internal_mutable_error_control();
  // @@protoc_insertion_point(field_mutable:mgard.pb.Header.error_control)
  return _msg;
}
inline void Header::set_allocated_error_control(::mgard::pb::ErrorControl* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.error_control_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = value->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
  }

  _impl_.error_control_ = reinterpret_cast<::mgard::pb::ErrorControl*>(value);
  // @@protoc_insertion_point(field_set_allocated:mgard.pb.Header.error_control)
}

// .mgard.pb.DomainDecomposition domain_decomposition = 7;
inline bool Header::has_domain_decomposition() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000020U);
  PROTOBUF_ASSUME(!value || _impl_.domain_decomposition_ != nullptr);
  return value;
}
inline void Header::clear_domain_decomposition() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.domain_decomposition_ != nullptr) _impl_.domain_decomposition_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
}
inline const ::mgard::pb::DomainDecomposition& Header::_internal_domain_decomposition() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::mgard::pb::DomainDecomposition* p = _impl_.domain_decomposition_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::mgard::pb::DomainDecomposition>(&::mgard::pb::DomainDecomposition_globals_);
}
inline const ::mgard::pb::DomainDecomposition& Header::domain_decomposition() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:mgard.pb.Header.domain_decomposition)
  return _internal_domain_decomposition();
}
inline void Header::unsafe_arena_set_allocated_domain_decomposition(
    ::mgard::pb::DomainDecomposition* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.domain_decomposition_);
  }
  _impl_.domain_decomposition_ = reinterpret_cast<::mgard::pb::DomainDecomposition*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mgard.pb.Header.domain_decomposition)
}
inline ::mgard::pb::DomainDecomposition* PROTOBUF_NULLABLE Header::release_domain_decomposition() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
  ::mgard::pb::DomainDecomposition* released = _impl_.domain_decomposition_;
  _impl_.domain_decomposition_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::mgard::pb::DomainDecomposition* PROTOBUF_NULLABLE Header::unsafe_arena_release_domain_decomposition() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:mgard.pb.Header.domain_decomposition)

  ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
  ::mgard::pb::DomainDecomposition* temp = _impl_.domain_decomposition_;
  _impl_.domain_decomposition_ = nullptr;
  return temp;
}
inline ::mgard::pb::DomainDecomposition* PROTOBUF_NONNULL Header::_internal_mutable_domain_decomposition() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.domain_decomposition_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::mgard::pb::DomainDecomposition>(GetArena());
    _impl_.domain_decomposition_ = reinterpret_cast<::mgard::pb::DomainDecomposition*>(p);
  }
  return _impl_.domain_decomposition_;
}
inline ::mgard::pb::DomainDecomposition* PROTOBUF_NONNULL Header::mutable_domain_decomposition()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  ::mgard::pb::DomainDecomposition* _msg = _internal_mutable_domain_decomposition();
  // @@protoc_insertion_point(field_mutable:mgard.pb.Header.domain_decomposition)
  return _msg;
}
inline void Header::set_allocated_domain_decomposition(::mgard::pb::DomainDecomposition* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.domain_decomposition_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = value->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
  }

  _impl_.domain_decomposition_ = reinterpret_cast<::mgard::pb::DomainDecomposition*>(value);
  // @@protoc_insertion_point(field_set_allocated:mgard.pb.Header.domain_decomposition)
}

// .mgard.pb.FunctionDecomposition function_decomposition = 8;
inline bool Header::has_function_decomposition() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000040U);
  PROTOBUF_ASSUME(!value || _impl_.function_decomposition_ != nullptr);
  return value;
}
inline void Header::clear_function_decomposition() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.function_decomposition_ != nullptr) _impl_.function_decomposition_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
}
inline const ::mgard::pb::FunctionDecomposition& Header::_internal_function_decomposition() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::mgard::pb::FunctionDecomposition* p = _impl_.function_decomposition_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::mgard::pb::FunctionDecomposition>(&::mgard::pb::FunctionDecomposition_globals_);
}
inline const ::mgard::pb::FunctionDecomposition& Header::function_decomposition() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:mgard.pb.Header.function_decomposition)
  return _internal_function_decomposition();
}
inline void Header::unsafe_arena_set_allocated_function_decomposition(
    ::mgard::pb::FunctionDecomposition* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.function_decomposition_);
  }
  _impl_.function_decomposition_ = reinterpret_cast<::mgard::pb::FunctionDecomposition*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000040U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mgard.pb.Header.function_decomposition)
}
inline ::mgard::pb::FunctionDecomposition* PROTOBUF_NULLABLE Header::release_function_decomposition() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
  ::mgard::pb::FunctionDecomposition* released = _impl_.function_decomposition_;
  _impl_.function_decomposition_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::mgard::pb::FunctionDecomposition* PROTOBUF_NULLABLE Header::unsafe_arena_release_function_decomposition() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:mgard.pb.Header.function_decomposition)

  ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
  ::mgard::pb::FunctionDecomposition* temp = _impl_.function_decomposition_;
  _impl_.function_decomposition_ = nullptr;
  return temp;
}
inline ::mgard::pb::FunctionDecomposition* PROTOBUF_NONNULL Header::_internal_mutable_function_decomposition() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.function_decomposition_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::mgard::pb::FunctionDecomposition>(GetArena());
    _impl_.function_decomposition_ = reinterpret_cast<::mgard::pb::FunctionDecomposition*>(p);
  }
  return _impl_.function_decomposition_;
}
inline ::mgard::pb::FunctionDecomposition* PROTOBUF_NONNULL Header::mutable_function_decomposition()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000040U);
  ::mgard::pb::FunctionDecomposition* _msg = _internal_mutable_function_decomposition();
  // @@protoc_insertion_point(field_mutable:mgard.pb.Header.function_decomposition)
  return _msg;
}
inline void Header::set_allocated_function_decomposition(::mgard::pb::FunctionDecomposition* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.function_decomposition_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = value->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000040U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
  }

  _impl_.function_decomposition_ = reinterpret_cast<::mgard::pb::FunctionDecomposition*>(value);
  // @@protoc_insertion_point(field_set_allocated:mgard.pb.Header.function_decomposition)
}

// .mgard.pb.Quantization quantization = 9;
inline bool Header::has_quantization() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000080U);
  PROTOBUF_ASSUME(!value || _impl_.quantization_ != nullptr);
  return value;
}
inline void Header::clear_quantization() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.quantization_ != nullptr) _impl_.quantization_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
}
inline const ::mgard::pb::Quantization& Header::_internal_quantization() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::mgard::pb::Quantization* p = _impl_.quantization_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::mgard::pb::Quantization>(&::mgard::pb::Quantization_globals_);
}
inline const ::mgard::pb::Quantization& Header::quantization() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:mgard.pb.Header.quantization)
  return _internal_quantization();
}
inline void Header::unsafe_arena_set_allocated_quantization(
    ::mgard::pb::Quantization* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.quantization_);
  }
  _impl_.quantization_ = reinterpret_cast<::mgard::pb::Quantization*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000080U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mgard.pb.Header.quantization)
}
inline ::mgard::pb::Quantization* PROTOBUF_NULLABLE Header::release_quantization() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
  ::mgard::pb::Quantization* released = _impl_.quantization_;
  _impl_.quantization_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::mgard::pb::Quantization* PROTOBUF_NULLABLE Header::unsafe_arena_release_quantization() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:mgard.pb.Header.quantization)

  ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
  ::mgard::pb::Quantization* temp = _impl_.quantization_;
  _impl_.quantization_ = nullptr;
  return temp;
}
inline ::mgard::pb::Quantization* PROTOBUF_NONNULL Header::_internal_mutable_quantization() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.quantization_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::mgard::pb::Quantization>(GetArena());
    _impl_.quantization_ = reinterpret_cast<::mgard::pb::Quantization*>(p);
  }
  return _impl_.quantization_;
}
inline ::mgard::pb::Quantization* PROTOBUF_NONNULL Header::mutable_quantization()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000080U);
  ::mgard::pb::Quantization* _msg = _internal_mutable_quantization();
  // @@protoc_insertion_point(field_mutable:mgard.pb.Header.quantization)
  return _msg;
}
inline void Header::set_allocated_quantization(::mgard::pb::Quantization* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.quantization_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = value->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000080U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
  }

  _impl_.quantization_ = reinterpret_cast<::mgard::pb::Quantization*>(value);
  // @@protoc_insertion_point(field_set_allocated:mgard.pb.Header.quantization)
}

// .mgard.pb.BitplaneEncoding bitplane_encoding = 10;
inline bool Header::has_bitplane_encoding() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000100U);
  PROTOBUF_ASSUME(!value || _impl_.bitplane_encoding_ != nullptr);
  return value;
}
inline void Header::clear_bitplane_encoding() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.bitplane_encoding_ != nullptr) _impl_.bitplane_encoding_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
}
inline const ::mgard::pb::BitplaneEncoding& Header::_internal_bitplane_encoding() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::mgard::pb::BitplaneEncoding* p = _impl_.bitplane_encoding_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::mgard::pb::BitplaneEncoding>(&::mgard::pb::BitplaneEncoding_globals_);
}
inline const ::mgard::pb::BitplaneEncoding& Header::bitplane_encoding() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:mgard.pb.Header.bitplane_encoding)
  return _internal_bitplane_encoding();
}
inline void Header::unsafe_arena_set_allocated_bitplane_encoding(
    ::mgard::pb::BitplaneEncoding* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.bitplane_encoding_);
  }
  _impl_.bitplane_encoding_ = reinterpret_cast<::mgard::pb::BitplaneEncoding*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000100U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mgard.pb.Header.bitplane_encoding)
}
inline ::mgard::pb::BitplaneEncoding* PROTOBUF_NULLABLE Header::release_bitplane_encoding() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
  ::mgard::pb::BitplaneEncoding* released = _impl_.bitplane_encoding_;
  _impl_.bitplane_encoding_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::mgard::pb::BitplaneEncoding* PROTOBUF_NULLABLE Header::unsafe_arena_release_bitplane_encoding() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:mgard.pb.Header.bitplane_encoding)

  ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
  ::mgard::pb::BitplaneEncoding* temp = _impl_.bitplane_encoding_;
  _impl_.bitplane_encoding_ = nullptr;
  return temp;
}
inline ::mgard::pb::BitplaneEncoding* PROTOBUF_NONNULL Header::_internal_mutable_bitplane_encoding() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.bitplane_encoding_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::mgard::pb::BitplaneEncoding>(GetArena());
    _impl_.bitplane_encoding_ = reinterpret_cast<::mgard::pb::BitplaneEncoding*>(p);
  }
  return _impl_.bitplane_encoding_;
}
inline ::mgard::pb::BitplaneEncoding* PROTOBUF_NONNULL Header::mutable_bitplane_encoding()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000100U);
  ::mgard::pb::BitplaneEncoding* _msg = _internal_mutable_bitplane_encoding();
  // @@protoc_insertion_point(field_mutable:mgard.pb.Header.bitplane_encoding)
  return _msg;
}
inline void Header::set_allocated_bitplane_encoding(::mgard::pb::BitplaneEncoding* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.bitplane_encoding_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = value->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000100U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
  }

  _impl_.bitplane_encoding_ = reinterpret_cast<::mgard::pb::BitplaneEncoding*>(value);
  // @@protoc_insertion_point(field_set_allocated:mgard.pb.Header.bitplane_encoding)
}

// .mgard.pb.Encoding encoding = 11;
inline bool Header::has_encoding() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000200U);
  PROTOBUF_ASSUME(!value || _impl_.encoding_ != nullptr);
  return value;
}
inline void Header::clear_encoding() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.encoding_ != nullptr) _impl_.encoding_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
}
inline const ::mgard::pb::Encoding& Header::_internal_encoding() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::mgard::pb::Encoding* p = _impl_.encoding_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::mgard::pb::Encoding>(&::mgard::pb::Encoding_globals_);
}
inline const ::mgard::pb::Encoding& Header::encoding() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:mgard.pb.Header.encoding)
  return _internal_encoding();
}
inline void Header::unsafe_arena_set_allocated_encoding(
    ::mgard::pb::Encoding* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.encoding_);
  }
  _impl_.encoding_ = reinterpret_cast<::mgard::pb::Encoding*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000200U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mgard.pb.Header.encoding)
}
inline ::mgard::pb::Encoding* PROTOBUF_NULLABLE Header::release_encoding() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
  ::mgard::pb::Encoding* released = _impl_.encoding_;
  _impl_.encoding_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::mgard::pb::Encoding* PROTOBUF_NULLABLE Header::unsafe_arena_release_encoding() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:mgard.pb.Header.encoding)

  ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
  ::mgard::pb::Encoding* temp = _impl_.encoding_;
  _impl_.encoding_ = nullptr;
  return temp;
}
inline ::mgard::pb::Encoding* PROTOBUF_NONNULL Header::_internal_mutable_encoding() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.encoding_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::mgard::pb::Encoding>(GetArena());
    _impl_.encoding_ = reinterpret_cast<::mgard::pb::Encoding*>(p);
  }
  return _impl_.encoding_;
}
inline ::mgard::pb::Encoding* PROTOBUF_NONNULL Header::mutable_encoding()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000200U);
  ::mgard::pb::Encoding* _msg = _internal_mutable_encoding();
  // @@protoc_insertion_point(field_mutable:mgard.pb.Header.encoding)
  return _msg;
}
inline void Header::set_allocated_encoding(::mgard::pb::Encoding* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.encoding_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = value->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000200U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
  }

  _impl_.encoding_ = reinterpret_cast<::mgard::pb::Encoding*>(value);
  // @@protoc_insertion_point(field_set_allocated:mgard.pb.Header.encoding)
}

// .mgard.pb.Device device = 12;
inline bool Header::has_device() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000400U);
  PROTOBUF_ASSUME(!value || _impl_.device_ != nullptr);
  return value;
}
inline void Header::clear_device() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.device_ != nullptr) _impl_.device_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000400U);
}
inline const ::mgard::pb::Device& Header::_internal_device() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::mgard::pb::Device* p = _impl_.device_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::mgard::pb::Device>(&::mgard::pb::Device_globals_);
}
inline const ::mgard::pb::Device& Header::device() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:mgard.pb.Header.device)
  return _internal_device();
}
inline void Header::unsafe_arena_set_allocated_device(
    ::mgard::pb::Device* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.device_);
  }
  _impl_.device_ = reinterpret_cast<::mgard::pb::Device*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000400U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000400U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mgard.pb.Header.device)
}
inline ::mgard::pb::Device* PROTOBUF_NULLABLE Header::release_device() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000400U);
  ::mgard::pb::Device* released = _impl_.device_;
  _impl_.device_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::mgard::pb::Device* PROTOBUF_NULLABLE Header::unsafe_arena_release_device() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:mgard.pb.Header.device)

  ClearHasBit(_impl_._has_bits_[0], 0x00000400U);
  ::mgard::pb::Device* temp = _impl_.device_;
  _impl_.device_ = nullptr;
  return temp;
}
inline ::mgard::pb::Device* PROTOBUF_NONNULL Header::_internal_mutable_device() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.device_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::mgard::pb::Device>(GetArena());
    _impl_.device_ = reinterpret_cast<::mgard::pb::Device*>(p);
  }
  return _impl_.device_;
}
inline ::mgard::pb::Device* PROTOBUF_NONNULL Header::mutable_device()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000400U);
  ::mgard::pb::Device* _msg = _internal_mutable_device();
  // @@protoc_insertion_point(field_mutable:mgard.pb.Header.device)
  return _msg;
}
inline void Header::set_allocated_device(::mgard::pb::Device* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.device_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = value->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000400U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000400U);
  }

  _impl_.device_ = reinterpret_cast<::mgard::pb::Device*>(value);
  // @@protoc_insertion_point(field_set_allocated:mgard.pb.Header.device)
}

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

// @@protoc_insertion_point(namespace_scope)
}  // namespace pb
}  // namespace mgard


namespace google {
namespace protobuf {

template <>
struct is_proto_enum<::mgard::pb::Domain_Topology> : std::true_type {};
template <>
inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::mgard::pb::Domain_Topology>() {
  return ::mgard::pb::Domain_Topology_descriptor();
}
template <>
struct is_proto_enum<::mgard::pb::Domain_Geometry> : std::true_type {};
template <>
inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::mgard::pb::Domain_Geometry>() {
  return ::mgard::pb::Domain_Geometry_descriptor();
}
template <>
struct is_proto_enum<::mgard::pb::Dataset_Type> : std::true_type {};
template <>
inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::mgard::pb::Dataset_Type>() {
  return ::mgard::pb::Dataset_Type_descriptor();
}
template <>
struct is_proto_enum<::mgard::pb::ErrorControl_Mode> : std::true_type {};
template <>
inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::mgard::pb::ErrorControl_Mode>() {
  return ::mgard::pb::ErrorControl_Mode_descriptor();
}
template <>
struct is_proto_enum<::mgard::pb::ErrorControl_Norm> : std::true_type {};
template <>
inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::mgard::pb::ErrorControl_Norm>() {
  return ::mgard::pb::ErrorControl_Norm_descriptor();
}
template <>
struct is_proto_enum<::mgard::pb::DomainDecomposition_Method> : std::true_type {};
template <>
inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::mgard::pb::DomainDecomposition_Method>() {
  return ::mgard::pb::DomainDecomposition_Method_descriptor();
}
template <>
struct is_proto_enum<::mgard::pb::FunctionDecomposition_Transform> : std::true_type {};
template <>
inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::mgard::pb::FunctionDecomposition_Transform>() {
  return ::mgard::pb::FunctionDecomposition_Transform_descriptor();
}
template <>
struct is_proto_enum<::mgard::pb::FunctionDecomposition_Hierarchy> : std::true_type {};
template <>
inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::mgard::pb::FunctionDecomposition_Hierarchy>() {
  return ::mgard::pb::FunctionDecomposition_Hierarchy_descriptor();
}
template <>
struct is_proto_enum<::mgard::pb::Quantization_Method> : std::true_type {};
template <>
inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::mgard::pb::Quantization_Method>() {
  return ::mgard::pb::Quantization_Method_descriptor();
}
template <>
struct is_proto_enum<::mgard::pb::Quantization_BinWidths> : std::true_type {};
template <>
inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::mgard::pb::Quantization_BinWidths>() {
  return ::mgard::pb::Quantization_BinWidths_descriptor();
}
template <>
struct is_proto_enum<::mgard::pb::Quantization_Type> : std::true_type {};
template <>
inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::mgard::pb::Quantization_Type>() {
  return ::mgard::pb::Quantization_Type_descriptor();
}
template <>
struct is_proto_enum<::mgard::pb::BitplaneEncoding_Method> : std::true_type {};
template <>
inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::mgard::pb::BitplaneEncoding_Method>() {
  return ::mgard::pb::BitplaneEncoding_Method_descriptor();
}
template <>
struct is_proto_enum<::mgard::pb::BitplaneEncoding_Type> : std::true_type {};
template <>
inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::mgard::pb::BitplaneEncoding_Type>() {
  return ::mgard::pb::BitplaneEncoding_Type_descriptor();
}
template <>
struct is_proto_enum<::mgard::pb::Encoding_Preprocessor> : std::true_type {};
template <>
inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::mgard::pb::Encoding_Preprocessor>() {
  return ::mgard::pb::Encoding_Preprocessor_descriptor();
}
template <>
struct is_proto_enum<::mgard::pb::Encoding_Compressor> : std::true_type {};
template <>
inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::mgard::pb::Encoding_Compressor>() {
  return ::mgard::pb::Encoding_Compressor_descriptor();
}
template <>
struct is_proto_enum<::mgard::pb::Device_Backend> : std::true_type {};
template <>
inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::mgard::pb::Device_Backend>() {
  return ::mgard::pb::Device_Backend_descriptor();
}

}  // namespace protobuf
}  // namespace google

// @@protoc_insertion_point(global_scope)

#include "google/protobuf/port_undef.inc"
// clang-format on

#endif  // mgard_2eproto_2epb_2eh
