chromium/out/Default/gen/third_party/tflite/src/tensorflow/lite/acceleration/configuration/configuration.pb.cc

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: tensorflow/lite/acceleration/configuration/configuration.proto

#include "tensorflow/lite/acceleration/configuration/configuration.pb.h"

#include <algorithm>

#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/wire_format_lite.h>
#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>

PROTOBUF_PRAGMA_INIT_SEG

_pb;
_pbi;

namespace tflite {
namespace proto {
PROTOBUF_CONSTEXPR ComputeSettings::ComputeSettings(
    ::_pbi::ConstantInitialized):{}
struct ComputeSettingsDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ComputeSettingsDefaultTypeInternal _ComputeSettings_default_instance_;
PROTOBUF_CONSTEXPR NNAPISettings::NNAPISettings(
    ::_pbi::ConstantInitialized):{}
struct NNAPISettingsDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 NNAPISettingsDefaultTypeInternal _NNAPISettings_default_instance_;
PROTOBUF_CONSTEXPR GPUSettings::GPUSettings(
    ::_pbi::ConstantInitialized):{}
struct GPUSettingsDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GPUSettingsDefaultTypeInternal _GPUSettings_default_instance_;
PROTOBUF_CONSTEXPR HexagonSettings::HexagonSettings(
    ::_pbi::ConstantInitialized):{}
struct HexagonSettingsDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HexagonSettingsDefaultTypeInternal _HexagonSettings_default_instance_;
PROTOBUF_CONSTEXPR XNNPackSettings::XNNPackSettings(
    ::_pbi::ConstantInitialized):{}
struct XNNPackSettingsDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 XNNPackSettingsDefaultTypeInternal _XNNPackSettings_default_instance_;
PROTOBUF_CONSTEXPR CoreMLSettings::CoreMLSettings(
    ::_pbi::ConstantInitialized):{}
struct CoreMLSettingsDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CoreMLSettingsDefaultTypeInternal _CoreMLSettings_default_instance_;
PROTOBUF_CONSTEXPR StableDelegateLoaderSettings::StableDelegateLoaderSettings(
    ::_pbi::ConstantInitialized):{}
struct StableDelegateLoaderSettingsDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 StableDelegateLoaderSettingsDefaultTypeInternal _StableDelegateLoaderSettings_default_instance_;
PROTOBUF_CONSTEXPR CompilationCachingSettings::CompilationCachingSettings(
    ::_pbi::ConstantInitialized):{}
struct CompilationCachingSettingsDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CompilationCachingSettingsDefaultTypeInternal _CompilationCachingSettings_default_instance_;
PROTOBUF_CONSTEXPR EdgeTpuDeviceSpec::EdgeTpuDeviceSpec(
    ::_pbi::ConstantInitialized):{}
struct EdgeTpuDeviceSpecDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EdgeTpuDeviceSpecDefaultTypeInternal _EdgeTpuDeviceSpec_default_instance_;
PROTOBUF_CONSTEXPR EdgeTpuInactivePowerConfig::EdgeTpuInactivePowerConfig(
    ::_pbi::ConstantInitialized):{}
struct EdgeTpuInactivePowerConfigDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EdgeTpuInactivePowerConfigDefaultTypeInternal _EdgeTpuInactivePowerConfig_default_instance_;
PROTOBUF_CONSTEXPR EdgeTpuSettings::EdgeTpuSettings(
    ::_pbi::ConstantInitialized):{}
struct EdgeTpuSettingsDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EdgeTpuSettingsDefaultTypeInternal _EdgeTpuSettings_default_instance_;
PROTOBUF_CONSTEXPR GoogleEdgeTpuSettings::GoogleEdgeTpuSettings(
    ::_pbi::ConstantInitialized):{}
struct GoogleEdgeTpuSettingsDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GoogleEdgeTpuSettingsDefaultTypeInternal _GoogleEdgeTpuSettings_default_instance_;
PROTOBUF_CONSTEXPR CoralSettings::CoralSettings(
    ::_pbi::ConstantInitialized):{}
struct CoralSettingsDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CoralSettingsDefaultTypeInternal _CoralSettings_default_instance_;
PROTOBUF_CONSTEXPR CPUSettings::CPUSettings(
    ::_pbi::ConstantInitialized):{}
struct CPUSettingsDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CPUSettingsDefaultTypeInternal _CPUSettings_default_instance_;
PROTOBUF_CONSTEXPR ArmNNSettings::ArmNNSettings(
    ::_pbi::ConstantInitialized):{}
struct ArmNNSettingsDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ArmNNSettingsDefaultTypeInternal _ArmNNSettings_default_instance_;
PROTOBUF_CONSTEXPR MtkNeuronSettings::MtkNeuronSettings(
    ::_pbi::ConstantInitialized):{}
struct MtkNeuronSettingsDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MtkNeuronSettingsDefaultTypeInternal _MtkNeuronSettings_default_instance_;
PROTOBUF_CONSTEXPR TFLiteSettings::TFLiteSettings(
    ::_pbi::ConstantInitialized):{}
struct TFLiteSettingsDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TFLiteSettingsDefaultTypeInternal _TFLiteSettings_default_instance_;
PROTOBUF_CONSTEXPR FallbackSettings::FallbackSettings(
    ::_pbi::ConstantInitialized):{}
struct FallbackSettingsDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FallbackSettingsDefaultTypeInternal _FallbackSettings_default_instance_;
PROTOBUF_CONSTEXPR BenchmarkMetric::BenchmarkMetric(
    ::_pbi::ConstantInitialized):{}
struct BenchmarkMetricDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BenchmarkMetricDefaultTypeInternal _BenchmarkMetric_default_instance_;
PROTOBUF_CONSTEXPR BenchmarkResult_InferenceOutput::BenchmarkResult_InferenceOutput(
    ::_pbi::ConstantInitialized):{}
struct BenchmarkResult_InferenceOutputDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BenchmarkResult_InferenceOutputDefaultTypeInternal _BenchmarkResult_InferenceOutput_default_instance_;
PROTOBUF_CONSTEXPR BenchmarkResult::BenchmarkResult(
    ::_pbi::ConstantInitialized):{}
struct BenchmarkResultDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BenchmarkResultDefaultTypeInternal _BenchmarkResult_default_instance_;
PROTOBUF_CONSTEXPR ErrorCode::ErrorCode(
    ::_pbi::ConstantInitialized):{}
struct ErrorCodeDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ErrorCodeDefaultTypeInternal _ErrorCode_default_instance_;
PROTOBUF_CONSTEXPR BenchmarkError::BenchmarkError(
    ::_pbi::ConstantInitialized):{}
struct BenchmarkErrorDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BenchmarkErrorDefaultTypeInternal _BenchmarkError_default_instance_;
PROTOBUF_CONSTEXPR BenchmarkEvent::BenchmarkEvent(
    ::_pbi::ConstantInitialized):{}
struct BenchmarkEventDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BenchmarkEventDefaultTypeInternal _BenchmarkEvent_default_instance_;
PROTOBUF_CONSTEXPR BestAccelerationDecision::BestAccelerationDecision(
    ::_pbi::ConstantInitialized):{}
struct BestAccelerationDecisionDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BestAccelerationDecisionDefaultTypeInternal _BestAccelerationDecision_default_instance_;
PROTOBUF_CONSTEXPR BenchmarkInitializationFailure::BenchmarkInitializationFailure(
    ::_pbi::ConstantInitialized):{}
struct BenchmarkInitializationFailureDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BenchmarkInitializationFailureDefaultTypeInternal _BenchmarkInitializationFailure_default_instance_;
PROTOBUF_CONSTEXPR MiniBenchmarkEvent::MiniBenchmarkEvent(
    ::_pbi::ConstantInitialized):{}
struct MiniBenchmarkEventDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MiniBenchmarkEventDefaultTypeInternal _MiniBenchmarkEvent_default_instance_;
PROTOBUF_CONSTEXPR ModelFile::ModelFile(
    ::_pbi::ConstantInitialized):{}
struct ModelFileDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ModelFileDefaultTypeInternal _ModelFile_default_instance_;
PROTOBUF_CONSTEXPR ModelIdGroup::ModelIdGroup(
    ::_pbi::ConstantInitialized):{}
struct ModelIdGroupDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ModelIdGroupDefaultTypeInternal _ModelIdGroup_default_instance_;
PROTOBUF_CONSTEXPR BenchmarkStoragePaths::BenchmarkStoragePaths(
    ::_pbi::ConstantInitialized):{}
struct BenchmarkStoragePathsDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BenchmarkStoragePathsDefaultTypeInternal _BenchmarkStoragePaths_default_instance_;
PROTOBUF_CONSTEXPR ValidationSettings::ValidationSettings(
    ::_pbi::ConstantInitialized):{}
struct ValidationSettingsDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ValidationSettingsDefaultTypeInternal _ValidationSettings_default_instance_;
PROTOBUF_CONSTEXPR MinibenchmarkSettings::MinibenchmarkSettings(
    ::_pbi::ConstantInitialized):{}
struct MinibenchmarkSettingsDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MinibenchmarkSettingsDefaultTypeInternal _MinibenchmarkSettings_default_instance_;
PROTOBUF_CONSTEXPR BenchmarkEventStorage::BenchmarkEventStorage(
    ::_pbi::ConstantInitialized):{}
struct BenchmarkEventStorageDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BenchmarkEventStorageDefaultTypeInternal _BenchmarkEventStorage_default_instance_;
}  // namespace proto
}  // namespace tflite
namespace tflite {
namespace proto {
bool CoreMLSettings_EnabledDevices_IsValid(int value) {}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> CoreMLSettings_EnabledDevices_strings[2] =;

static const char CoreMLSettings_EnabledDevices_names[] =;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry CoreMLSettings_EnabledDevices_entries[] =;

static const int CoreMLSettings_EnabledDevices_entries_by_number[] =;

const std::string& CoreMLSettings_EnabledDevices_Name(
    CoreMLSettings_EnabledDevices value) {}
bool CoreMLSettings_EnabledDevices_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CoreMLSettings_EnabledDevices* value) {}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr CoreMLSettings_EnabledDevices CoreMLSettings::DEVICES_ALL;
constexpr CoreMLSettings_EnabledDevices CoreMLSettings::DEVICES_WITH_NEURAL_ENGINE;
constexpr CoreMLSettings_EnabledDevices CoreMLSettings::EnabledDevices_MIN;
constexpr CoreMLSettings_EnabledDevices CoreMLSettings::EnabledDevices_MAX;
constexpr int CoreMLSettings::EnabledDevices_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool EdgeTpuDeviceSpec_PlatformType_IsValid(int value) {}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> EdgeTpuDeviceSpec_PlatformType_strings[4] =;

static const char EdgeTpuDeviceSpec_PlatformType_names[] =;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry EdgeTpuDeviceSpec_PlatformType_entries[] =;

static const int EdgeTpuDeviceSpec_PlatformType_entries_by_number[] =;

const std::string& EdgeTpuDeviceSpec_PlatformType_Name(
    EdgeTpuDeviceSpec_PlatformType value) {}
bool EdgeTpuDeviceSpec_PlatformType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, EdgeTpuDeviceSpec_PlatformType* value) {}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr EdgeTpuDeviceSpec_PlatformType EdgeTpuDeviceSpec::MMIO;
constexpr EdgeTpuDeviceSpec_PlatformType EdgeTpuDeviceSpec::REFERENCE;
constexpr EdgeTpuDeviceSpec_PlatformType EdgeTpuDeviceSpec::SIMULATOR;
constexpr EdgeTpuDeviceSpec_PlatformType EdgeTpuDeviceSpec::REMOTE_SIMULATOR;
constexpr EdgeTpuDeviceSpec_PlatformType EdgeTpuDeviceSpec::PlatformType_MIN;
constexpr EdgeTpuDeviceSpec_PlatformType EdgeTpuDeviceSpec::PlatformType_MAX;
constexpr int EdgeTpuDeviceSpec::PlatformType_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool EdgeTpuSettings_FloatTruncationType_IsValid(int value) {}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> EdgeTpuSettings_FloatTruncationType_strings[4] =;

static const char EdgeTpuSettings_FloatTruncationType_names[] =;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry EdgeTpuSettings_FloatTruncationType_entries[] =;

static const int EdgeTpuSettings_FloatTruncationType_entries_by_number[] =;

const std::string& EdgeTpuSettings_FloatTruncationType_Name(
    EdgeTpuSettings_FloatTruncationType value) {}
bool EdgeTpuSettings_FloatTruncationType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, EdgeTpuSettings_FloatTruncationType* value) {}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr EdgeTpuSettings_FloatTruncationType EdgeTpuSettings::UNSPECIFIED;
constexpr EdgeTpuSettings_FloatTruncationType EdgeTpuSettings::NO_TRUNCATION;
constexpr EdgeTpuSettings_FloatTruncationType EdgeTpuSettings::BFLOAT16;
constexpr EdgeTpuSettings_FloatTruncationType EdgeTpuSettings::HALF;
constexpr EdgeTpuSettings_FloatTruncationType EdgeTpuSettings::FloatTruncationType_MIN;
constexpr EdgeTpuSettings_FloatTruncationType EdgeTpuSettings::FloatTruncationType_MAX;
constexpr int EdgeTpuSettings::FloatTruncationType_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool EdgeTpuSettings_QosClass_IsValid(int value) {}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> EdgeTpuSettings_QosClass_strings[3] =;

static const char EdgeTpuSettings_QosClass_names[] =;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry EdgeTpuSettings_QosClass_entries[] =;

static const int EdgeTpuSettings_QosClass_entries_by_number[] =;

const std::string& EdgeTpuSettings_QosClass_Name(
    EdgeTpuSettings_QosClass value) {}
bool EdgeTpuSettings_QosClass_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, EdgeTpuSettings_QosClass* value) {}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr EdgeTpuSettings_QosClass EdgeTpuSettings::QOS_UNDEFINED;
constexpr EdgeTpuSettings_QosClass EdgeTpuSettings::BEST_EFFORT;
constexpr EdgeTpuSettings_QosClass EdgeTpuSettings::REALTIME;
constexpr EdgeTpuSettings_QosClass EdgeTpuSettings::QosClass_MIN;
constexpr EdgeTpuSettings_QosClass EdgeTpuSettings::QosClass_MAX;
constexpr int EdgeTpuSettings::QosClass_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool EdgeTpuSettings_UseLayerIrTgcBackend_IsValid(int value) {}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> EdgeTpuSettings_UseLayerIrTgcBackend_strings[4] =;

static const char EdgeTpuSettings_UseLayerIrTgcBackend_names[] =;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry EdgeTpuSettings_UseLayerIrTgcBackend_entries[] =;

static const int EdgeTpuSettings_UseLayerIrTgcBackend_entries_by_number[] =;

const std::string& EdgeTpuSettings_UseLayerIrTgcBackend_Name(
    EdgeTpuSettings_UseLayerIrTgcBackend value) {}
bool EdgeTpuSettings_UseLayerIrTgcBackend_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, EdgeTpuSettings_UseLayerIrTgcBackend* value) {}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr EdgeTpuSettings_UseLayerIrTgcBackend EdgeTpuSettings::USE_LAYER_IR_TGC_BACKEND_UNSPECIFIED;
constexpr EdgeTpuSettings_UseLayerIrTgcBackend EdgeTpuSettings::USE_LAYER_IR_TGC_BACKEND_NO;
constexpr EdgeTpuSettings_UseLayerIrTgcBackend EdgeTpuSettings::USE_LAYER_IR_TGC_BACKEND_YES;
constexpr EdgeTpuSettings_UseLayerIrTgcBackend EdgeTpuSettings::USE_LAYER_IR_TGC_BACKEND_AUTO;
constexpr EdgeTpuSettings_UseLayerIrTgcBackend EdgeTpuSettings::UseLayerIrTgcBackend_MIN;
constexpr EdgeTpuSettings_UseLayerIrTgcBackend EdgeTpuSettings::UseLayerIrTgcBackend_MAX;
constexpr int EdgeTpuSettings::UseLayerIrTgcBackend_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool GoogleEdgeTpuSettings_Priority_IsValid(int value) {}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> GoogleEdgeTpuSettings_Priority_strings[4] =;

static const char GoogleEdgeTpuSettings_Priority_names[] =;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry GoogleEdgeTpuSettings_Priority_entries[] =;

static const int GoogleEdgeTpuSettings_Priority_entries_by_number[] =;

const std::string& GoogleEdgeTpuSettings_Priority_Name(
    GoogleEdgeTpuSettings_Priority value) {}
bool GoogleEdgeTpuSettings_Priority_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, GoogleEdgeTpuSettings_Priority* value) {}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr GoogleEdgeTpuSettings_Priority GoogleEdgeTpuSettings::PRIORITY_UNDEFINED;
constexpr GoogleEdgeTpuSettings_Priority GoogleEdgeTpuSettings::PRIORITY_LOW;
constexpr GoogleEdgeTpuSettings_Priority GoogleEdgeTpuSettings::PRIORITY_MEDIUM;
constexpr GoogleEdgeTpuSettings_Priority GoogleEdgeTpuSettings::PRIORITY_HIGH;
constexpr GoogleEdgeTpuSettings_Priority GoogleEdgeTpuSettings::Priority_MIN;
constexpr GoogleEdgeTpuSettings_Priority GoogleEdgeTpuSettings::Priority_MAX;
constexpr int GoogleEdgeTpuSettings::Priority_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool GoogleEdgeTpuSettings_TriState_IsValid(int value) {}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> GoogleEdgeTpuSettings_TriState_strings[3] =;

static const char GoogleEdgeTpuSettings_TriState_names[] =;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry GoogleEdgeTpuSettings_TriState_entries[] =;

static const int GoogleEdgeTpuSettings_TriState_entries_by_number[] =;

const std::string& GoogleEdgeTpuSettings_TriState_Name(
    GoogleEdgeTpuSettings_TriState value) {}
bool GoogleEdgeTpuSettings_TriState_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, GoogleEdgeTpuSettings_TriState* value) {}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr GoogleEdgeTpuSettings_TriState GoogleEdgeTpuSettings::TRISTATE_UNDEFINED;
constexpr GoogleEdgeTpuSettings_TriState GoogleEdgeTpuSettings::TRISTATE_FALSE;
constexpr GoogleEdgeTpuSettings_TriState GoogleEdgeTpuSettings::TRISTATE_TRUE;
constexpr GoogleEdgeTpuSettings_TriState GoogleEdgeTpuSettings::TriState_MIN;
constexpr GoogleEdgeTpuSettings_TriState GoogleEdgeTpuSettings::TriState_MAX;
constexpr int GoogleEdgeTpuSettings::TriState_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool CoralSettings_Performance_IsValid(int value) {}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> CoralSettings_Performance_strings[5] =;

static const char CoralSettings_Performance_names[] =;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry CoralSettings_Performance_entries[] =;

static const int CoralSettings_Performance_entries_by_number[] =;

const std::string& CoralSettings_Performance_Name(
    CoralSettings_Performance value) {}
bool CoralSettings_Performance_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CoralSettings_Performance* value) {}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr CoralSettings_Performance CoralSettings::UNDEFINED;
constexpr CoralSettings_Performance CoralSettings::MAXIMUM;
constexpr CoralSettings_Performance CoralSettings::HIGH;
constexpr CoralSettings_Performance CoralSettings::MEDIUM;
constexpr CoralSettings_Performance CoralSettings::LOW;
constexpr CoralSettings_Performance CoralSettings::Performance_MIN;
constexpr CoralSettings_Performance CoralSettings::Performance_MAX;
constexpr int CoralSettings::Performance_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool MtkNeuronSettings_ExecutionPreference_IsValid(int value) {}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> MtkNeuronSettings_ExecutionPreference_strings[5] =;

static const char MtkNeuronSettings_ExecutionPreference_names[] =;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry MtkNeuronSettings_ExecutionPreference_entries[] =;

static const int MtkNeuronSettings_ExecutionPreference_entries_by_number[] =;

const std::string& MtkNeuronSettings_ExecutionPreference_Name(
    MtkNeuronSettings_ExecutionPreference value) {}
bool MtkNeuronSettings_ExecutionPreference_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, MtkNeuronSettings_ExecutionPreference* value) {}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr MtkNeuronSettings_ExecutionPreference MtkNeuronSettings::PREFERENCE_UNDEFINED;
constexpr MtkNeuronSettings_ExecutionPreference MtkNeuronSettings::PREFERENCE_LOW_POWER;
constexpr MtkNeuronSettings_ExecutionPreference MtkNeuronSettings::PREFERENCE_FAST_SINGLE_ANSWER;
constexpr MtkNeuronSettings_ExecutionPreference MtkNeuronSettings::PREFERENCE_SUSTAINED_SPEED;
constexpr MtkNeuronSettings_ExecutionPreference MtkNeuronSettings::PREFERENCE_TURBO_BOOST;
constexpr MtkNeuronSettings_ExecutionPreference MtkNeuronSettings::ExecutionPreference_MIN;
constexpr MtkNeuronSettings_ExecutionPreference MtkNeuronSettings::ExecutionPreference_MAX;
constexpr int MtkNeuronSettings::ExecutionPreference_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool MtkNeuronSettings_ExecutionPriority_IsValid(int value) {}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> MtkNeuronSettings_ExecutionPriority_strings[4] =;

static const char MtkNeuronSettings_ExecutionPriority_names[] =;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry MtkNeuronSettings_ExecutionPriority_entries[] =;

static const int MtkNeuronSettings_ExecutionPriority_entries_by_number[] =;

const std::string& MtkNeuronSettings_ExecutionPriority_Name(
    MtkNeuronSettings_ExecutionPriority value) {}
bool MtkNeuronSettings_ExecutionPriority_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, MtkNeuronSettings_ExecutionPriority* value) {}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr MtkNeuronSettings_ExecutionPriority MtkNeuronSettings::PRIORITY_UNDEFINED;
constexpr MtkNeuronSettings_ExecutionPriority MtkNeuronSettings::PRIORITY_LOW;
constexpr MtkNeuronSettings_ExecutionPriority MtkNeuronSettings::PRIORITY_MEDIUM;
constexpr MtkNeuronSettings_ExecutionPriority MtkNeuronSettings::PRIORITY_HIGH;
constexpr MtkNeuronSettings_ExecutionPriority MtkNeuronSettings::ExecutionPriority_MIN;
constexpr MtkNeuronSettings_ExecutionPriority MtkNeuronSettings::ExecutionPriority_MAX;
constexpr int MtkNeuronSettings::ExecutionPriority_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool MtkNeuronSettings_OptimizationHint_IsValid(int value) {}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> MtkNeuronSettings_OptimizationHint_strings[4] =;

static const char MtkNeuronSettings_OptimizationHint_names[] =;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry MtkNeuronSettings_OptimizationHint_entries[] =;

static const int MtkNeuronSettings_OptimizationHint_entries_by_number[] =;

const std::string& MtkNeuronSettings_OptimizationHint_Name(
    MtkNeuronSettings_OptimizationHint value) {}
bool MtkNeuronSettings_OptimizationHint_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, MtkNeuronSettings_OptimizationHint* value) {}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr MtkNeuronSettings_OptimizationHint MtkNeuronSettings::OPTIMIZATION_NONE;
constexpr MtkNeuronSettings_OptimizationHint MtkNeuronSettings::OPTIMIZATION_LOW_LATENCY;
constexpr MtkNeuronSettings_OptimizationHint MtkNeuronSettings::OPTIMIZATION_DEEP_FUSION;
constexpr MtkNeuronSettings_OptimizationHint MtkNeuronSettings::OPTIMIZATION_BATCH_PROCESSING;
constexpr MtkNeuronSettings_OptimizationHint MtkNeuronSettings::OptimizationHint_MIN;
constexpr MtkNeuronSettings_OptimizationHint MtkNeuronSettings::OptimizationHint_MAX;
constexpr int MtkNeuronSettings::OptimizationHint_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool MtkNeuronSettings_OperationCheckMode_IsValid(int value) {}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> MtkNeuronSettings_OperationCheckMode_strings[3] =;

static const char MtkNeuronSettings_OperationCheckMode_names[] =;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry MtkNeuronSettings_OperationCheckMode_entries[] =;

static const int MtkNeuronSettings_OperationCheckMode_entries_by_number[] =;

const std::string& MtkNeuronSettings_OperationCheckMode_Name(
    MtkNeuronSettings_OperationCheckMode value) {}
bool MtkNeuronSettings_OperationCheckMode_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, MtkNeuronSettings_OperationCheckMode* value) {}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr MtkNeuronSettings_OperationCheckMode MtkNeuronSettings::NO_OPERATION_CHECK;
constexpr MtkNeuronSettings_OperationCheckMode MtkNeuronSettings::PER_NODE_OPERATION_CHECK;
constexpr MtkNeuronSettings_OperationCheckMode MtkNeuronSettings::PRE_OPERATION_CHECK;
constexpr MtkNeuronSettings_OperationCheckMode MtkNeuronSettings::OperationCheckMode_MIN;
constexpr MtkNeuronSettings_OperationCheckMode MtkNeuronSettings::OperationCheckMode_MAX;
constexpr int MtkNeuronSettings::OperationCheckMode_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool ExecutionPreference_IsValid(int value) {}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> ExecutionPreference_strings[4] =;

static const char ExecutionPreference_names[] =;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ExecutionPreference_entries[] =;

static const int ExecutionPreference_entries_by_number[] =;

const std::string& ExecutionPreference_Name(
    ExecutionPreference value) {}
bool ExecutionPreference_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ExecutionPreference* value) {}
bool Delegate_IsValid(int value) {}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> Delegate_strings[10] =;

static const char Delegate_names[] =;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry Delegate_entries[] =;

static const int Delegate_entries_by_number[] =;

const std::string& Delegate_Name(
    Delegate value) {}
bool Delegate_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Delegate* value) {}
bool NNAPIExecutionPreference_IsValid(int value) {}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> NNAPIExecutionPreference_strings[4] =;

static const char NNAPIExecutionPreference_names[] =;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry NNAPIExecutionPreference_entries[] =;

static const int NNAPIExecutionPreference_entries_by_number[] =;

const std::string& NNAPIExecutionPreference_Name(
    NNAPIExecutionPreference value) {}
bool NNAPIExecutionPreference_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, NNAPIExecutionPreference* value) {}
bool NNAPIExecutionPriority_IsValid(int value) {}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> NNAPIExecutionPriority_strings[4] =;

static const char NNAPIExecutionPriority_names[] =;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry NNAPIExecutionPriority_entries[] =;

static const int NNAPIExecutionPriority_entries_by_number[] =;

const std::string& NNAPIExecutionPriority_Name(
    NNAPIExecutionPriority value) {}
bool NNAPIExecutionPriority_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, NNAPIExecutionPriority* value) {}
bool GPUBackend_IsValid(int value) {}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> GPUBackend_strings[3] =;

static const char GPUBackend_names[] =;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry GPUBackend_entries[] =;

static const int GPUBackend_entries_by_number[] =;

const std::string& GPUBackend_Name(
    GPUBackend value) {}
bool GPUBackend_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, GPUBackend* value) {}
bool GPUInferencePriority_IsValid(int value) {}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> GPUInferencePriority_strings[4] =;

static const char GPUInferencePriority_names[] =;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry GPUInferencePriority_entries[] =;

static const int GPUInferencePriority_entries_by_number[] =;

const std::string& GPUInferencePriority_Name(
    GPUInferencePriority value) {}
bool GPUInferencePriority_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, GPUInferencePriority* value) {}
bool GPUInferenceUsage_IsValid(int value) {}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> GPUInferenceUsage_strings[2] =;

static const char GPUInferenceUsage_names[] =;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry GPUInferenceUsage_entries[] =;

static const int GPUInferenceUsage_entries_by_number[] =;

const std::string& GPUInferenceUsage_Name(
    GPUInferenceUsage value) {}
bool GPUInferenceUsage_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, GPUInferenceUsage* value) {}
bool XNNPackFlags_IsValid(int value) {}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> XNNPackFlags_strings[10] =;

static const char XNNPackFlags_names[] =;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry XNNPackFlags_entries[] =;

static const int XNNPackFlags_entries_by_number[] =;

const std::string& XNNPackFlags_Name(
    XNNPackFlags value) {}
bool XNNPackFlags_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, XNNPackFlags* value) {}
bool EdgeTpuPowerState_IsValid(int value) {}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> EdgeTpuPowerState_strings[8] =;

static const char EdgeTpuPowerState_names[] =;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry EdgeTpuPowerState_entries[] =;

static const int EdgeTpuPowerState_entries_by_number[] =;

const std::string& EdgeTpuPowerState_Name(
    EdgeTpuPowerState value) {}
bool EdgeTpuPowerState_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, EdgeTpuPowerState* value) {}
bool BenchmarkEventType_IsValid(int value) {}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> BenchmarkEventType_strings[6] =;

static const char BenchmarkEventType_names[] =;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry BenchmarkEventType_entries[] =;

static const int BenchmarkEventType_entries_by_number[] =;

const std::string& BenchmarkEventType_Name(
    BenchmarkEventType value) {}
bool BenchmarkEventType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, BenchmarkEventType* value) {}
bool BenchmarkStage_IsValid(int value) {}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> BenchmarkStage_strings[3] =;

static const char BenchmarkStage_names[] =;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry BenchmarkStage_entries[] =;

static const int BenchmarkStage_entries_by_number[] =;

const std::string& BenchmarkStage_Name(
    BenchmarkStage value) {}
bool BenchmarkStage_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, BenchmarkStage* value) {}

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

class ComputeSettings::_Internal {};

const ::tflite::proto::TFLiteSettings&
ComputeSettings::_Internal::tflite_settings(const ComputeSettings* msg) {}
const ::tflite::proto::MinibenchmarkSettings&
ComputeSettings::_Internal::settings_to_test_locally(const ComputeSettings* msg) {}
ComputeSettings::ComputeSettings(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
ComputeSettings::ComputeSettings(const ComputeSettings& from)
  :{}

inline void ComputeSettings::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

ComputeSettings::~ComputeSettings() {}

inline void ComputeSettings::SharedDtor() {}

void ComputeSettings::SetCachedSize(int size) const {}

void ComputeSettings::Clear() {}

const char* ComputeSettings::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* ComputeSettings::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t ComputeSettings::ByteSizeLong() const {}

void ComputeSettings::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void ComputeSettings::MergeFrom(const ComputeSettings& from) {}

void ComputeSettings::CopyFrom(const ComputeSettings& from) {}

bool ComputeSettings::IsInitialized() const {}

void ComputeSettings::InternalSwap(ComputeSettings* other) {}

std::string ComputeSettings::GetTypeName() const {}


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

class NNAPISettings::_Internal {};

const ::tflite::proto::FallbackSettings&
NNAPISettings::_Internal::fallback_settings(const NNAPISettings* msg) {}
NNAPISettings::NNAPISettings(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
NNAPISettings::NNAPISettings(const NNAPISettings& from)
  :{}

inline void NNAPISettings::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

NNAPISettings::~NNAPISettings() {}

inline void NNAPISettings::SharedDtor() {}

void NNAPISettings::SetCachedSize(int size) const {}

void NNAPISettings::Clear() {}

const char* NNAPISettings::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* NNAPISettings::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t NNAPISettings::ByteSizeLong() const {}

void NNAPISettings::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void NNAPISettings::MergeFrom(const NNAPISettings& from) {}

void NNAPISettings::CopyFrom(const NNAPISettings& from) {}

bool NNAPISettings::IsInitialized() const {}

void NNAPISettings::InternalSwap(NNAPISettings* other) {}

std::string NNAPISettings::GetTypeName() const {}


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

class GPUSettings::_Internal {};

GPUSettings::GPUSettings(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
GPUSettings::GPUSettings(const GPUSettings& from)
  :{}

inline void GPUSettings::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

GPUSettings::~GPUSettings() {}

inline void GPUSettings::SharedDtor() {}

void GPUSettings::SetCachedSize(int size) const {}

void GPUSettings::Clear() {}

const char* GPUSettings::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* GPUSettings::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t GPUSettings::ByteSizeLong() const {}

void GPUSettings::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void GPUSettings::MergeFrom(const GPUSettings& from) {}

void GPUSettings::CopyFrom(const GPUSettings& from) {}

bool GPUSettings::IsInitialized() const {}

void GPUSettings::InternalSwap(GPUSettings* other) {}

std::string GPUSettings::GetTypeName() const {}


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

class HexagonSettings::_Internal {};

HexagonSettings::HexagonSettings(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
HexagonSettings::HexagonSettings(const HexagonSettings& from)
  :{}

inline void HexagonSettings::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

HexagonSettings::~HexagonSettings() {}

inline void HexagonSettings::SharedDtor() {}

void HexagonSettings::SetCachedSize(int size) const {}

void HexagonSettings::Clear() {}

const char* HexagonSettings::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* HexagonSettings::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t HexagonSettings::ByteSizeLong() const {}

void HexagonSettings::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void HexagonSettings::MergeFrom(const HexagonSettings& from) {}

void HexagonSettings::CopyFrom(const HexagonSettings& from) {}

bool HexagonSettings::IsInitialized() const {}

void HexagonSettings::InternalSwap(HexagonSettings* other) {}

std::string HexagonSettings::GetTypeName() const {}


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

class XNNPackSettings::_Internal {};

XNNPackSettings::XNNPackSettings(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
XNNPackSettings::XNNPackSettings(const XNNPackSettings& from)
  :{}

inline void XNNPackSettings::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

XNNPackSettings::~XNNPackSettings() {}

inline void XNNPackSettings::SharedDtor() {}

void XNNPackSettings::SetCachedSize(int size) const {}

void XNNPackSettings::Clear() {}

const char* XNNPackSettings::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* XNNPackSettings::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t XNNPackSettings::ByteSizeLong() const {}

void XNNPackSettings::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void XNNPackSettings::MergeFrom(const XNNPackSettings& from) {}

void XNNPackSettings::CopyFrom(const XNNPackSettings& from) {}

bool XNNPackSettings::IsInitialized() const {}

void XNNPackSettings::InternalSwap(XNNPackSettings* other) {}

std::string XNNPackSettings::GetTypeName() const {}


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

class CoreMLSettings::_Internal {};

CoreMLSettings::CoreMLSettings(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
CoreMLSettings::CoreMLSettings(const CoreMLSettings& from)
  :{}

inline void CoreMLSettings::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

CoreMLSettings::~CoreMLSettings() {}

inline void CoreMLSettings::SharedDtor() {}

void CoreMLSettings::SetCachedSize(int size) const {}

void CoreMLSettings::Clear() {}

const char* CoreMLSettings::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* CoreMLSettings::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t CoreMLSettings::ByteSizeLong() const {}

void CoreMLSettings::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void CoreMLSettings::MergeFrom(const CoreMLSettings& from) {}

void CoreMLSettings::CopyFrom(const CoreMLSettings& from) {}

bool CoreMLSettings::IsInitialized() const {}

void CoreMLSettings::InternalSwap(CoreMLSettings* other) {}

std::string CoreMLSettings::GetTypeName() const {}


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

class StableDelegateLoaderSettings::_Internal {};

StableDelegateLoaderSettings::StableDelegateLoaderSettings(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
StableDelegateLoaderSettings::StableDelegateLoaderSettings(const StableDelegateLoaderSettings& from)
  :{}

inline void StableDelegateLoaderSettings::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

StableDelegateLoaderSettings::~StableDelegateLoaderSettings() {}

inline void StableDelegateLoaderSettings::SharedDtor() {}

void StableDelegateLoaderSettings::SetCachedSize(int size) const {}

void StableDelegateLoaderSettings::Clear() {}

const char* StableDelegateLoaderSettings::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* StableDelegateLoaderSettings::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t StableDelegateLoaderSettings::ByteSizeLong() const {}

void StableDelegateLoaderSettings::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void StableDelegateLoaderSettings::MergeFrom(const StableDelegateLoaderSettings& from) {}

void StableDelegateLoaderSettings::CopyFrom(const StableDelegateLoaderSettings& from) {}

bool StableDelegateLoaderSettings::IsInitialized() const {}

void StableDelegateLoaderSettings::InternalSwap(StableDelegateLoaderSettings* other) {}

std::string StableDelegateLoaderSettings::GetTypeName() const {}


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

class CompilationCachingSettings::_Internal {};

CompilationCachingSettings::CompilationCachingSettings(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
CompilationCachingSettings::CompilationCachingSettings(const CompilationCachingSettings& from)
  :{}

inline void CompilationCachingSettings::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

CompilationCachingSettings::~CompilationCachingSettings() {}

inline void CompilationCachingSettings::SharedDtor() {}

void CompilationCachingSettings::SetCachedSize(int size) const {}

void CompilationCachingSettings::Clear() {}

const char* CompilationCachingSettings::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* CompilationCachingSettings::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t CompilationCachingSettings::ByteSizeLong() const {}

void CompilationCachingSettings::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void CompilationCachingSettings::MergeFrom(const CompilationCachingSettings& from) {}

void CompilationCachingSettings::CopyFrom(const CompilationCachingSettings& from) {}

bool CompilationCachingSettings::IsInitialized() const {}

void CompilationCachingSettings::InternalSwap(CompilationCachingSettings* other) {}

std::string CompilationCachingSettings::GetTypeName() const {}


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

class EdgeTpuDeviceSpec::_Internal {};

EdgeTpuDeviceSpec::EdgeTpuDeviceSpec(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
EdgeTpuDeviceSpec::EdgeTpuDeviceSpec(const EdgeTpuDeviceSpec& from)
  :{}

inline void EdgeTpuDeviceSpec::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

EdgeTpuDeviceSpec::~EdgeTpuDeviceSpec() {}

inline void EdgeTpuDeviceSpec::SharedDtor() {}

void EdgeTpuDeviceSpec::SetCachedSize(int size) const {}

void EdgeTpuDeviceSpec::Clear() {}

const char* EdgeTpuDeviceSpec::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* EdgeTpuDeviceSpec::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t EdgeTpuDeviceSpec::ByteSizeLong() const {}

void EdgeTpuDeviceSpec::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void EdgeTpuDeviceSpec::MergeFrom(const EdgeTpuDeviceSpec& from) {}

void EdgeTpuDeviceSpec::CopyFrom(const EdgeTpuDeviceSpec& from) {}

bool EdgeTpuDeviceSpec::IsInitialized() const {}

void EdgeTpuDeviceSpec::InternalSwap(EdgeTpuDeviceSpec* other) {}

std::string EdgeTpuDeviceSpec::GetTypeName() const {}


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

class EdgeTpuInactivePowerConfig::_Internal {};

EdgeTpuInactivePowerConfig::EdgeTpuInactivePowerConfig(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
EdgeTpuInactivePowerConfig::EdgeTpuInactivePowerConfig(const EdgeTpuInactivePowerConfig& from)
  :{}

inline void EdgeTpuInactivePowerConfig::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

EdgeTpuInactivePowerConfig::~EdgeTpuInactivePowerConfig() {}

inline void EdgeTpuInactivePowerConfig::SharedDtor() {}

void EdgeTpuInactivePowerConfig::SetCachedSize(int size) const {}

void EdgeTpuInactivePowerConfig::Clear() {}

const char* EdgeTpuInactivePowerConfig::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* EdgeTpuInactivePowerConfig::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t EdgeTpuInactivePowerConfig::ByteSizeLong() const {}

void EdgeTpuInactivePowerConfig::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void EdgeTpuInactivePowerConfig::MergeFrom(const EdgeTpuInactivePowerConfig& from) {}

void EdgeTpuInactivePowerConfig::CopyFrom(const EdgeTpuInactivePowerConfig& from) {}

bool EdgeTpuInactivePowerConfig::IsInitialized() const {}

void EdgeTpuInactivePowerConfig::InternalSwap(EdgeTpuInactivePowerConfig* other) {}

std::string EdgeTpuInactivePowerConfig::GetTypeName() const {}


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

class EdgeTpuSettings::_Internal {};

const ::tflite::proto::EdgeTpuDeviceSpec&
EdgeTpuSettings::_Internal::edgetpu_device_spec(const EdgeTpuSettings* msg) {}
EdgeTpuSettings::EdgeTpuSettings(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
EdgeTpuSettings::EdgeTpuSettings(const EdgeTpuSettings& from)
  :{}

inline void EdgeTpuSettings::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

EdgeTpuSettings::~EdgeTpuSettings() {}

inline void EdgeTpuSettings::SharedDtor() {}

void EdgeTpuSettings::SetCachedSize(int size) const {}

void EdgeTpuSettings::Clear() {}

const char* EdgeTpuSettings::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* EdgeTpuSettings::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t EdgeTpuSettings::ByteSizeLong() const {}

void EdgeTpuSettings::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void EdgeTpuSettings::MergeFrom(const EdgeTpuSettings& from) {}

void EdgeTpuSettings::CopyFrom(const EdgeTpuSettings& from) {}

bool EdgeTpuSettings::IsInitialized() const {}

void EdgeTpuSettings::InternalSwap(EdgeTpuSettings* other) {}

std::string EdgeTpuSettings::GetTypeName() const {}


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

class GoogleEdgeTpuSettings::_Internal {};

GoogleEdgeTpuSettings::GoogleEdgeTpuSettings(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
GoogleEdgeTpuSettings::GoogleEdgeTpuSettings(const GoogleEdgeTpuSettings& from)
  :{}

inline void GoogleEdgeTpuSettings::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

GoogleEdgeTpuSettings::~GoogleEdgeTpuSettings() {}

inline void GoogleEdgeTpuSettings::SharedDtor() {}

void GoogleEdgeTpuSettings::SetCachedSize(int size) const {}

void GoogleEdgeTpuSettings::Clear() {}

const char* GoogleEdgeTpuSettings::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* GoogleEdgeTpuSettings::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t GoogleEdgeTpuSettings::ByteSizeLong() const {}

void GoogleEdgeTpuSettings::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void GoogleEdgeTpuSettings::MergeFrom(const GoogleEdgeTpuSettings& from) {}

void GoogleEdgeTpuSettings::CopyFrom(const GoogleEdgeTpuSettings& from) {}

bool GoogleEdgeTpuSettings::IsInitialized() const {}

void GoogleEdgeTpuSettings::InternalSwap(GoogleEdgeTpuSettings* other) {}

std::string GoogleEdgeTpuSettings::GetTypeName() const {}


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

class CoralSettings::_Internal {};

CoralSettings::CoralSettings(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
CoralSettings::CoralSettings(const CoralSettings& from)
  :{}

inline void CoralSettings::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

CoralSettings::~CoralSettings() {}

inline void CoralSettings::SharedDtor() {}

void CoralSettings::SetCachedSize(int size) const {}

void CoralSettings::Clear() {}

const char* CoralSettings::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* CoralSettings::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t CoralSettings::ByteSizeLong() const {}

void CoralSettings::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void CoralSettings::MergeFrom(const CoralSettings& from) {}

void CoralSettings::CopyFrom(const CoralSettings& from) {}

bool CoralSettings::IsInitialized() const {}

void CoralSettings::InternalSwap(CoralSettings* other) {}

std::string CoralSettings::GetTypeName() const {}


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

class CPUSettings::_Internal {};

CPUSettings::CPUSettings(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
CPUSettings::CPUSettings(const CPUSettings& from)
  :{}

inline void CPUSettings::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

CPUSettings::~CPUSettings() {}

inline void CPUSettings::SharedDtor() {}

void CPUSettings::SetCachedSize(int size) const {}

void CPUSettings::Clear() {}

const char* CPUSettings::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* CPUSettings::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t CPUSettings::ByteSizeLong() const {}

void CPUSettings::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void CPUSettings::MergeFrom(const CPUSettings& from) {}

void CPUSettings::CopyFrom(const CPUSettings& from) {}

bool CPUSettings::IsInitialized() const {}

void CPUSettings::InternalSwap(CPUSettings* other) {}

std::string CPUSettings::GetTypeName() const {}


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

class ArmNNSettings::_Internal {};

ArmNNSettings::ArmNNSettings(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
ArmNNSettings::ArmNNSettings(const ArmNNSettings& from)
  :{}

inline void ArmNNSettings::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

ArmNNSettings::~ArmNNSettings() {}

inline void ArmNNSettings::SharedDtor() {}

void ArmNNSettings::SetCachedSize(int size) const {}

void ArmNNSettings::Clear() {}

const char* ArmNNSettings::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* ArmNNSettings::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t ArmNNSettings::ByteSizeLong() const {}

void ArmNNSettings::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void ArmNNSettings::MergeFrom(const ArmNNSettings& from) {}

void ArmNNSettings::CopyFrom(const ArmNNSettings& from) {}

bool ArmNNSettings::IsInitialized() const {}

void ArmNNSettings::InternalSwap(ArmNNSettings* other) {}

std::string ArmNNSettings::GetTypeName() const {}


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

class MtkNeuronSettings::_Internal {};

MtkNeuronSettings::MtkNeuronSettings(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
MtkNeuronSettings::MtkNeuronSettings(const MtkNeuronSettings& from)
  :{}

inline void MtkNeuronSettings::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

MtkNeuronSettings::~MtkNeuronSettings() {}

inline void MtkNeuronSettings::SharedDtor() {}

void MtkNeuronSettings::SetCachedSize(int size) const {}

void MtkNeuronSettings::Clear() {}

const char* MtkNeuronSettings::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* MtkNeuronSettings::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t MtkNeuronSettings::ByteSizeLong() const {}

void MtkNeuronSettings::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void MtkNeuronSettings::MergeFrom(const MtkNeuronSettings& from) {}

void MtkNeuronSettings::CopyFrom(const MtkNeuronSettings& from) {}

bool MtkNeuronSettings::IsInitialized() const {}

void MtkNeuronSettings::InternalSwap(MtkNeuronSettings* other) {}

std::string MtkNeuronSettings::GetTypeName() const {}


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

class TFLiteSettings::_Internal {};

const ::tflite::proto::NNAPISettings&
TFLiteSettings::_Internal::nnapi_settings(const TFLiteSettings* msg) {}
const ::tflite::proto::GPUSettings&
TFLiteSettings::_Internal::gpu_settings(const TFLiteSettings* msg) {}
const ::tflite::proto::HexagonSettings&
TFLiteSettings::_Internal::hexagon_settings(const TFLiteSettings* msg) {}
const ::tflite::proto::XNNPackSettings&
TFLiteSettings::_Internal::xnnpack_settings(const TFLiteSettings* msg) {}
const ::tflite::proto::CoreMLSettings&
TFLiteSettings::_Internal::coreml_settings(const TFLiteSettings* msg) {}
const ::tflite::proto::CPUSettings&
TFLiteSettings::_Internal::cpu_settings(const TFLiteSettings* msg) {}
const ::tflite::proto::EdgeTpuSettings&
TFLiteSettings::_Internal::edgetpu_settings(const TFLiteSettings* msg) {}
const ::tflite::proto::CoralSettings&
TFLiteSettings::_Internal::coral_settings(const TFLiteSettings* msg) {}
const ::tflite::proto::FallbackSettings&
TFLiteSettings::_Internal::fallback_settings(const TFLiteSettings* msg) {}
const ::tflite::proto::StableDelegateLoaderSettings&
TFLiteSettings::_Internal::stable_delegate_loader_settings(const TFLiteSettings* msg) {}
const ::tflite::proto::GoogleEdgeTpuSettings&
TFLiteSettings::_Internal::google_edgetpu_settings(const TFLiteSettings* msg) {}
const ::tflite::proto::CompilationCachingSettings&
TFLiteSettings::_Internal::compilation_caching_settings(const TFLiteSettings* msg) {}
const ::tflite::proto::ArmNNSettings&
TFLiteSettings::_Internal::armnn_settings(const TFLiteSettings* msg) {}
const ::tflite::proto::MtkNeuronSettings&
TFLiteSettings::_Internal::mtk_neuron_settings(const TFLiteSettings* msg) {}
TFLiteSettings::TFLiteSettings(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
TFLiteSettings::TFLiteSettings(const TFLiteSettings& from)
  :{}

inline void TFLiteSettings::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

TFLiteSettings::~TFLiteSettings() {}

inline void TFLiteSettings::SharedDtor() {}

void TFLiteSettings::SetCachedSize(int size) const {}

void TFLiteSettings::Clear() {}

const char* TFLiteSettings::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* TFLiteSettings::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t TFLiteSettings::ByteSizeLong() const {}

void TFLiteSettings::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void TFLiteSettings::MergeFrom(const TFLiteSettings& from) {}

void TFLiteSettings::CopyFrom(const TFLiteSettings& from) {}

bool TFLiteSettings::IsInitialized() const {}

void TFLiteSettings::InternalSwap(TFLiteSettings* other) {}

std::string TFLiteSettings::GetTypeName() const {}


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

class FallbackSettings::_Internal {};

FallbackSettings::FallbackSettings(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
FallbackSettings::FallbackSettings(const FallbackSettings& from)
  :{}

inline void FallbackSettings::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

FallbackSettings::~FallbackSettings() {}

inline void FallbackSettings::SharedDtor() {}

void FallbackSettings::SetCachedSize(int size) const {}

void FallbackSettings::Clear() {}

const char* FallbackSettings::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* FallbackSettings::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t FallbackSettings::ByteSizeLong() const {}

void FallbackSettings::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void FallbackSettings::MergeFrom(const FallbackSettings& from) {}

void FallbackSettings::CopyFrom(const FallbackSettings& from) {}

bool FallbackSettings::IsInitialized() const {}

void FallbackSettings::InternalSwap(FallbackSettings* other) {}

std::string FallbackSettings::GetTypeName() const {}


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

class BenchmarkMetric::_Internal {};

BenchmarkMetric::BenchmarkMetric(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
BenchmarkMetric::BenchmarkMetric(const BenchmarkMetric& from)
  :{}

inline void BenchmarkMetric::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

BenchmarkMetric::~BenchmarkMetric() {}

inline void BenchmarkMetric::SharedDtor() {}

void BenchmarkMetric::SetCachedSize(int size) const {}

void BenchmarkMetric::Clear() {}

const char* BenchmarkMetric::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* BenchmarkMetric::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t BenchmarkMetric::ByteSizeLong() const {}

void BenchmarkMetric::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void BenchmarkMetric::MergeFrom(const BenchmarkMetric& from) {}

void BenchmarkMetric::CopyFrom(const BenchmarkMetric& from) {}

bool BenchmarkMetric::IsInitialized() const {}

void BenchmarkMetric::InternalSwap(BenchmarkMetric* other) {}

std::string BenchmarkMetric::GetTypeName() const {}


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

class BenchmarkResult_InferenceOutput::_Internal {};

BenchmarkResult_InferenceOutput::BenchmarkResult_InferenceOutput(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
BenchmarkResult_InferenceOutput::BenchmarkResult_InferenceOutput(const BenchmarkResult_InferenceOutput& from)
  :{}

inline void BenchmarkResult_InferenceOutput::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

BenchmarkResult_InferenceOutput::~BenchmarkResult_InferenceOutput() {}

inline void BenchmarkResult_InferenceOutput::SharedDtor() {}

void BenchmarkResult_InferenceOutput::SetCachedSize(int size) const {}

void BenchmarkResult_InferenceOutput::Clear() {}

const char* BenchmarkResult_InferenceOutput::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* BenchmarkResult_InferenceOutput::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t BenchmarkResult_InferenceOutput::ByteSizeLong() const {}

void BenchmarkResult_InferenceOutput::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void BenchmarkResult_InferenceOutput::MergeFrom(const BenchmarkResult_InferenceOutput& from) {}

void BenchmarkResult_InferenceOutput::CopyFrom(const BenchmarkResult_InferenceOutput& from) {}

bool BenchmarkResult_InferenceOutput::IsInitialized() const {}

void BenchmarkResult_InferenceOutput::InternalSwap(BenchmarkResult_InferenceOutput* other) {}

std::string BenchmarkResult_InferenceOutput::GetTypeName() const {}


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

class BenchmarkResult::_Internal {};

BenchmarkResult::BenchmarkResult(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
BenchmarkResult::BenchmarkResult(const BenchmarkResult& from)
  :{}

inline void BenchmarkResult::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

BenchmarkResult::~BenchmarkResult() {}

inline void BenchmarkResult::SharedDtor() {}

void BenchmarkResult::SetCachedSize(int size) const {}

void BenchmarkResult::Clear() {}

const char* BenchmarkResult::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* BenchmarkResult::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t BenchmarkResult::ByteSizeLong() const {}

void BenchmarkResult::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void BenchmarkResult::MergeFrom(const BenchmarkResult& from) {}

void BenchmarkResult::CopyFrom(const BenchmarkResult& from) {}

bool BenchmarkResult::IsInitialized() const {}

void BenchmarkResult::InternalSwap(BenchmarkResult* other) {}

std::string BenchmarkResult::GetTypeName() const {}


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

class ErrorCode::_Internal {};

ErrorCode::ErrorCode(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
ErrorCode::ErrorCode(const ErrorCode& from)
  :{}

inline void ErrorCode::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

ErrorCode::~ErrorCode() {}

inline void ErrorCode::SharedDtor() {}

void ErrorCode::SetCachedSize(int size) const {}

void ErrorCode::Clear() {}

const char* ErrorCode::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* ErrorCode::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t ErrorCode::ByteSizeLong() const {}

void ErrorCode::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void ErrorCode::MergeFrom(const ErrorCode& from) {}

void ErrorCode::CopyFrom(const ErrorCode& from) {}

bool ErrorCode::IsInitialized() const {}

void ErrorCode::InternalSwap(ErrorCode* other) {}

std::string ErrorCode::GetTypeName() const {}


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

class BenchmarkError::_Internal {};

BenchmarkError::BenchmarkError(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
BenchmarkError::BenchmarkError(const BenchmarkError& from)
  :{}

inline void BenchmarkError::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

BenchmarkError::~BenchmarkError() {}

inline void BenchmarkError::SharedDtor() {}

void BenchmarkError::SetCachedSize(int size) const {}

void BenchmarkError::Clear() {}

const char* BenchmarkError::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* BenchmarkError::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t BenchmarkError::ByteSizeLong() const {}

void BenchmarkError::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void BenchmarkError::MergeFrom(const BenchmarkError& from) {}

void BenchmarkError::CopyFrom(const BenchmarkError& from) {}

bool BenchmarkError::IsInitialized() const {}

void BenchmarkError::InternalSwap(BenchmarkError* other) {}

std::string BenchmarkError::GetTypeName() const {}


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

class BenchmarkEvent::_Internal {};

const ::tflite::proto::TFLiteSettings&
BenchmarkEvent::_Internal::tflite_settings(const BenchmarkEvent* msg) {}
const ::tflite::proto::BenchmarkResult&
BenchmarkEvent::_Internal::result(const BenchmarkEvent* msg) {}
const ::tflite::proto::BenchmarkError&
BenchmarkEvent::_Internal::error(const BenchmarkEvent* msg) {}
BenchmarkEvent::BenchmarkEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
BenchmarkEvent::BenchmarkEvent(const BenchmarkEvent& from)
  :{}

inline void BenchmarkEvent::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

BenchmarkEvent::~BenchmarkEvent() {}

inline void BenchmarkEvent::SharedDtor() {}

void BenchmarkEvent::SetCachedSize(int size) const {}

void BenchmarkEvent::Clear() {}

const char* BenchmarkEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* BenchmarkEvent::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t BenchmarkEvent::ByteSizeLong() const {}

void BenchmarkEvent::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void BenchmarkEvent::MergeFrom(const BenchmarkEvent& from) {}

void BenchmarkEvent::CopyFrom(const BenchmarkEvent& from) {}

bool BenchmarkEvent::IsInitialized() const {}

void BenchmarkEvent::InternalSwap(BenchmarkEvent* other) {}

std::string BenchmarkEvent::GetTypeName() const {}


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

class BestAccelerationDecision::_Internal {};

const ::tflite::proto::BenchmarkEvent&
BestAccelerationDecision::_Internal::min_latency_event(const BestAccelerationDecision* msg) {}
BestAccelerationDecision::BestAccelerationDecision(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
BestAccelerationDecision::BestAccelerationDecision(const BestAccelerationDecision& from)
  :{}

inline void BestAccelerationDecision::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

BestAccelerationDecision::~BestAccelerationDecision() {}

inline void BestAccelerationDecision::SharedDtor() {}

void BestAccelerationDecision::SetCachedSize(int size) const {}

void BestAccelerationDecision::Clear() {}

const char* BestAccelerationDecision::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* BestAccelerationDecision::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t BestAccelerationDecision::ByteSizeLong() const {}

void BestAccelerationDecision::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void BestAccelerationDecision::MergeFrom(const BestAccelerationDecision& from) {}

void BestAccelerationDecision::CopyFrom(const BestAccelerationDecision& from) {}

bool BestAccelerationDecision::IsInitialized() const {}

void BestAccelerationDecision::InternalSwap(BestAccelerationDecision* other) {}

std::string BestAccelerationDecision::GetTypeName() const {}


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

class BenchmarkInitializationFailure::_Internal {};

BenchmarkInitializationFailure::BenchmarkInitializationFailure(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
BenchmarkInitializationFailure::BenchmarkInitializationFailure(const BenchmarkInitializationFailure& from)
  :{}

inline void BenchmarkInitializationFailure::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

BenchmarkInitializationFailure::~BenchmarkInitializationFailure() {}

inline void BenchmarkInitializationFailure::SharedDtor() {}

void BenchmarkInitializationFailure::SetCachedSize(int size) const {}

void BenchmarkInitializationFailure::Clear() {}

const char* BenchmarkInitializationFailure::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* BenchmarkInitializationFailure::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t BenchmarkInitializationFailure::ByteSizeLong() const {}

void BenchmarkInitializationFailure::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void BenchmarkInitializationFailure::MergeFrom(const BenchmarkInitializationFailure& from) {}

void BenchmarkInitializationFailure::CopyFrom(const BenchmarkInitializationFailure& from) {}

bool BenchmarkInitializationFailure::IsInitialized() const {}

void BenchmarkInitializationFailure::InternalSwap(BenchmarkInitializationFailure* other) {}

std::string BenchmarkInitializationFailure::GetTypeName() const {}


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

class MiniBenchmarkEvent::_Internal {};

const ::tflite::proto::BestAccelerationDecision&
MiniBenchmarkEvent::_Internal::best_acceleration_decision(const MiniBenchmarkEvent* msg) {}
const ::tflite::proto::BenchmarkInitializationFailure&
MiniBenchmarkEvent::_Internal::initialization_failure(const MiniBenchmarkEvent* msg) {}
const ::tflite::proto::BenchmarkEvent&
MiniBenchmarkEvent::_Internal::benchmark_event(const MiniBenchmarkEvent* msg) {}
MiniBenchmarkEvent::MiniBenchmarkEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
MiniBenchmarkEvent::MiniBenchmarkEvent(const MiniBenchmarkEvent& from)
  :{}

inline void MiniBenchmarkEvent::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

MiniBenchmarkEvent::~MiniBenchmarkEvent() {}

inline void MiniBenchmarkEvent::SharedDtor() {}

void MiniBenchmarkEvent::SetCachedSize(int size) const {}

void MiniBenchmarkEvent::Clear() {}

const char* MiniBenchmarkEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* MiniBenchmarkEvent::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t MiniBenchmarkEvent::ByteSizeLong() const {}

void MiniBenchmarkEvent::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void MiniBenchmarkEvent::MergeFrom(const MiniBenchmarkEvent& from) {}

void MiniBenchmarkEvent::CopyFrom(const MiniBenchmarkEvent& from) {}

bool MiniBenchmarkEvent::IsInitialized() const {}

void MiniBenchmarkEvent::InternalSwap(MiniBenchmarkEvent* other) {}

std::string MiniBenchmarkEvent::GetTypeName() const {}


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

class ModelFile::_Internal {};

const ::tflite::proto::ModelIdGroup&
ModelFile::_Internal::model_id_group(const ModelFile* msg) {}
ModelFile::ModelFile(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
ModelFile::ModelFile(const ModelFile& from)
  :{}

inline void ModelFile::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

ModelFile::~ModelFile() {}

inline void ModelFile::SharedDtor() {}

void ModelFile::SetCachedSize(int size) const {}

void ModelFile::Clear() {}

const char* ModelFile::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* ModelFile::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t ModelFile::ByteSizeLong() const {}

void ModelFile::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void ModelFile::MergeFrom(const ModelFile& from) {}

void ModelFile::CopyFrom(const ModelFile& from) {}

bool ModelFile::IsInitialized() const {}

void ModelFile::InternalSwap(ModelFile* other) {}

std::string ModelFile::GetTypeName() const {}


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

class ModelIdGroup::_Internal {};

ModelIdGroup::ModelIdGroup(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
ModelIdGroup::ModelIdGroup(const ModelIdGroup& from)
  :{}

inline void ModelIdGroup::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

ModelIdGroup::~ModelIdGroup() {}

inline void ModelIdGroup::SharedDtor() {}

void ModelIdGroup::SetCachedSize(int size) const {}

void ModelIdGroup::Clear() {}

const char* ModelIdGroup::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* ModelIdGroup::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t ModelIdGroup::ByteSizeLong() const {}

void ModelIdGroup::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void ModelIdGroup::MergeFrom(const ModelIdGroup& from) {}

void ModelIdGroup::CopyFrom(const ModelIdGroup& from) {}

bool ModelIdGroup::IsInitialized() const {}

void ModelIdGroup::InternalSwap(ModelIdGroup* other) {}

std::string ModelIdGroup::GetTypeName() const {}


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

class BenchmarkStoragePaths::_Internal {};

BenchmarkStoragePaths::BenchmarkStoragePaths(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
BenchmarkStoragePaths::BenchmarkStoragePaths(const BenchmarkStoragePaths& from)
  :{}

inline void BenchmarkStoragePaths::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

BenchmarkStoragePaths::~BenchmarkStoragePaths() {}

inline void BenchmarkStoragePaths::SharedDtor() {}

void BenchmarkStoragePaths::SetCachedSize(int size) const {}

void BenchmarkStoragePaths::Clear() {}

const char* BenchmarkStoragePaths::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* BenchmarkStoragePaths::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t BenchmarkStoragePaths::ByteSizeLong() const {}

void BenchmarkStoragePaths::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void BenchmarkStoragePaths::MergeFrom(const BenchmarkStoragePaths& from) {}

void BenchmarkStoragePaths::CopyFrom(const BenchmarkStoragePaths& from) {}

bool BenchmarkStoragePaths::IsInitialized() const {}

void BenchmarkStoragePaths::InternalSwap(BenchmarkStoragePaths* other) {}

std::string BenchmarkStoragePaths::GetTypeName() const {}


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

class ValidationSettings::_Internal {};

ValidationSettings::ValidationSettings(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
ValidationSettings::ValidationSettings(const ValidationSettings& from)
  :{}

inline void ValidationSettings::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

ValidationSettings::~ValidationSettings() {}

inline void ValidationSettings::SharedDtor() {}

void ValidationSettings::SetCachedSize(int size) const {}

void ValidationSettings::Clear() {}

const char* ValidationSettings::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* ValidationSettings::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t ValidationSettings::ByteSizeLong() const {}

void ValidationSettings::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void ValidationSettings::MergeFrom(const ValidationSettings& from) {}

void ValidationSettings::CopyFrom(const ValidationSettings& from) {}

bool ValidationSettings::IsInitialized() const {}

void ValidationSettings::InternalSwap(ValidationSettings* other) {}

std::string ValidationSettings::GetTypeName() const {}


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

class MinibenchmarkSettings::_Internal {};

const ::tflite::proto::ModelFile&
MinibenchmarkSettings::_Internal::model_file(const MinibenchmarkSettings* msg) {}
const ::tflite::proto::BenchmarkStoragePaths&
MinibenchmarkSettings::_Internal::storage_paths(const MinibenchmarkSettings* msg) {}
const ::tflite::proto::ValidationSettings&
MinibenchmarkSettings::_Internal::validation_settings(const MinibenchmarkSettings* msg) {}
MinibenchmarkSettings::MinibenchmarkSettings(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
MinibenchmarkSettings::MinibenchmarkSettings(const MinibenchmarkSettings& from)
  :{}

inline void MinibenchmarkSettings::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

MinibenchmarkSettings::~MinibenchmarkSettings() {}

inline void MinibenchmarkSettings::SharedDtor() {}

void MinibenchmarkSettings::SetCachedSize(int size) const {}

void MinibenchmarkSettings::Clear() {}

const char* MinibenchmarkSettings::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* MinibenchmarkSettings::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t MinibenchmarkSettings::ByteSizeLong() const {}

void MinibenchmarkSettings::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void MinibenchmarkSettings::MergeFrom(const MinibenchmarkSettings& from) {}

void MinibenchmarkSettings::CopyFrom(const MinibenchmarkSettings& from) {}

bool MinibenchmarkSettings::IsInitialized() const {}

void MinibenchmarkSettings::InternalSwap(MinibenchmarkSettings* other) {}

std::string MinibenchmarkSettings::GetTypeName() const {}


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

class BenchmarkEventStorage::_Internal {};

const ::tflite::proto::ModelIdGroup&
BenchmarkEventStorage::_Internal::model_id_group(const BenchmarkEventStorage* msg) {}
const ::tflite::proto::BenchmarkEvent&
BenchmarkEventStorage::_Internal::benchmark_event(const BenchmarkEventStorage* msg) {}
BenchmarkEventStorage::BenchmarkEventStorage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
BenchmarkEventStorage::BenchmarkEventStorage(const BenchmarkEventStorage& from)
  :{}

inline void BenchmarkEventStorage::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

BenchmarkEventStorage::~BenchmarkEventStorage() {}

inline void BenchmarkEventStorage::SharedDtor() {}

void BenchmarkEventStorage::SetCachedSize(int size) const {}

void BenchmarkEventStorage::Clear() {}

const char* BenchmarkEventStorage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* BenchmarkEventStorage::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t BenchmarkEventStorage::ByteSizeLong() const {}

void BenchmarkEventStorage::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void BenchmarkEventStorage::MergeFrom(const BenchmarkEventStorage& from) {}

void BenchmarkEventStorage::CopyFrom(const BenchmarkEventStorage& from) {}

bool BenchmarkEventStorage::IsInitialized() const {}

void BenchmarkEventStorage::InternalSwap(BenchmarkEventStorage* other) {}

std::string BenchmarkEventStorage::GetTypeName() const {}


// @@protoc_insertion_point(namespace_scope)
}  // namespace proto
}  // namespace tflite
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::tflite::proto::ComputeSettings*
Arena::CreateMaybeMessage< ::tflite::proto::ComputeSettings >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::tflite::proto::NNAPISettings*
Arena::CreateMaybeMessage< ::tflite::proto::NNAPISettings >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::tflite::proto::GPUSettings*
Arena::CreateMaybeMessage< ::tflite::proto::GPUSettings >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::tflite::proto::HexagonSettings*
Arena::CreateMaybeMessage< ::tflite::proto::HexagonSettings >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::tflite::proto::XNNPackSettings*
Arena::CreateMaybeMessage< ::tflite::proto::XNNPackSettings >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::tflite::proto::CoreMLSettings*
Arena::CreateMaybeMessage< ::tflite::proto::CoreMLSettings >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::tflite::proto::StableDelegateLoaderSettings*
Arena::CreateMaybeMessage< ::tflite::proto::StableDelegateLoaderSettings >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::tflite::proto::CompilationCachingSettings*
Arena::CreateMaybeMessage< ::tflite::proto::CompilationCachingSettings >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::tflite::proto::EdgeTpuDeviceSpec*
Arena::CreateMaybeMessage< ::tflite::proto::EdgeTpuDeviceSpec >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::tflite::proto::EdgeTpuInactivePowerConfig*
Arena::CreateMaybeMessage< ::tflite::proto::EdgeTpuInactivePowerConfig >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::tflite::proto::EdgeTpuSettings*
Arena::CreateMaybeMessage< ::tflite::proto::EdgeTpuSettings >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::tflite::proto::GoogleEdgeTpuSettings*
Arena::CreateMaybeMessage< ::tflite::proto::GoogleEdgeTpuSettings >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::tflite::proto::CoralSettings*
Arena::CreateMaybeMessage< ::tflite::proto::CoralSettings >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::tflite::proto::CPUSettings*
Arena::CreateMaybeMessage< ::tflite::proto::CPUSettings >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::tflite::proto::ArmNNSettings*
Arena::CreateMaybeMessage< ::tflite::proto::ArmNNSettings >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::tflite::proto::MtkNeuronSettings*
Arena::CreateMaybeMessage< ::tflite::proto::MtkNeuronSettings >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::tflite::proto::TFLiteSettings*
Arena::CreateMaybeMessage< ::tflite::proto::TFLiteSettings >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::tflite::proto::FallbackSettings*
Arena::CreateMaybeMessage< ::tflite::proto::FallbackSettings >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::tflite::proto::BenchmarkMetric*
Arena::CreateMaybeMessage< ::tflite::proto::BenchmarkMetric >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::tflite::proto::BenchmarkResult_InferenceOutput*
Arena::CreateMaybeMessage< ::tflite::proto::BenchmarkResult_InferenceOutput >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::tflite::proto::BenchmarkResult*
Arena::CreateMaybeMessage< ::tflite::proto::BenchmarkResult >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::tflite::proto::ErrorCode*
Arena::CreateMaybeMessage< ::tflite::proto::ErrorCode >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::tflite::proto::BenchmarkError*
Arena::CreateMaybeMessage< ::tflite::proto::BenchmarkError >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::tflite::proto::BenchmarkEvent*
Arena::CreateMaybeMessage< ::tflite::proto::BenchmarkEvent >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::tflite::proto::BestAccelerationDecision*
Arena::CreateMaybeMessage< ::tflite::proto::BestAccelerationDecision >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::tflite::proto::BenchmarkInitializationFailure*
Arena::CreateMaybeMessage< ::tflite::proto::BenchmarkInitializationFailure >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::tflite::proto::MiniBenchmarkEvent*
Arena::CreateMaybeMessage< ::tflite::proto::MiniBenchmarkEvent >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::tflite::proto::ModelFile*
Arena::CreateMaybeMessage< ::tflite::proto::ModelFile >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::tflite::proto::ModelIdGroup*
Arena::CreateMaybeMessage< ::tflite::proto::ModelIdGroup >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::tflite::proto::BenchmarkStoragePaths*
Arena::CreateMaybeMessage< ::tflite::proto::BenchmarkStoragePaths >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::tflite::proto::ValidationSettings*
Arena::CreateMaybeMessage< ::tflite::proto::ValidationSettings >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::tflite::proto::MinibenchmarkSettings*
Arena::CreateMaybeMessage< ::tflite::proto::MinibenchmarkSettings >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::tflite::proto::BenchmarkEventStorage*
Arena::CreateMaybeMessage< ::tflite::proto::BenchmarkEventStorage >(Arena* arena) {}
PROTOBUF_NAMESPACE_CLOSE

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